<?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="1999566976857398962">"Taip"</string>
    <string name="no" msgid="5541738710521607130">"Ne"</string>
    <string name="create" msgid="986997212165228751">"Kurti"</string>
    <string name="allow" msgid="3763244945363657722">"Leisti"</string>
    <string name="deny" msgid="7326117222944479942">"Atmesti"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Įjungti"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Nežinomas"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Palieskite norėdami rodyti informaciją"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Liko atlikti # veiksmą ir būsite kūrėjas (-a).}one{Liko atlikti # veiksmą ir būsite kūrėjas (-a).}few{Liko atlikti # veiksmus ir būsite kūrėjas (-a).}many{Liko atlikti # veiksmo ir būsite kūrėjas (-a).}other{Liko atlikti # veiksmų ir būsite kūrėjas (-a).}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Dabar esate kūrėjas!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Nereikia, jūs jau esate kūrėjas."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Pirmiausia įgalinkite kūrėjo parinktis."</string>
    <string name="dev_settings_available_to_admin_only_warning" msgid="3408243404879083111">"Tik naudotojai administratoriai gali pasiekti kūrėjo nustatymus."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sistema"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Aptarnaujama"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Paslaugos neteikiamos"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radijas išjungtas"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Tarptinklinis ryšys"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Neveikia tarptinklinis ryšys"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Atsijungęs (-usi)"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Jungiama"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Prisijungta"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Pristabdyta"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Nežinoma"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Peržiūra"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Padaryti mažesnius"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Padaryti didesnius"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Visada"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Priekinis rodinys įjungiamas sulenkus įrenginį"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Tik žaidimai, vaizdo įrašai ir kt."</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"Priekinis rodinys įjungiamas programose, kurios išjungia neaktyvų ekraną"</string>
    <string name="stay_awake_on_lockscreen_title" msgid="8088456642083051068">"Perbraukite aukštyn ir tęskite"</string>
    <string name="stay_awake_on_lockscreen_summary" msgid="2299351813382522952">"Sulenkite telefoną ir perbraukite aukštyn priekiniame rodinyje, jei norite toliau naudoti programą, arba palaukite kelias sekundes, kol ekranas bus užrakintas"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Niekada"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Priekinis rodinys užrakinamas sulenkus įrenginį"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Automatinio pasukimo naudojimas"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Veido aptikimo funkcija naudoja priekinį fotoaparatą, kad padidintų automatinio pasukimo tikslumą. Vaizdai niekada neišsaugomi ir nesiunčiami „Google“."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Matoma visiems netol. esant. „Bluetooth“ įr. (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Matoma visiems netoliese esan. „Bluetooth“ įreng."</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Nematoma kitiems „Bluetooth“ įrenginiams"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Matoma tik suporuotiems įrenginiams."</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"„Bluetooth“ įrenginiai"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Įrenginio pavadinimas"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Pervardyti šį įrenginį"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Pervardyti"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Atjungti įrenginį?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Susieti naują įrenginį"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"Bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Susieti dešinę ausį"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Susieti kairę ausį"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Susiekite kitą ausį"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Kairysis klausos įrenginys prijungtas.\n\nNorėdami susieti dešinįjį, įsitikinkite, kad jis įjungtas ir paruoštas susieti."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Dešinysis klausos įrenginys prijungtas.\n\nNorėdami susieti kairįjį, įsitikinkite, kad jis įjungtas ir paruoštas susieti."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Susieti dešinę ausį"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Susieti kairę ausį"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Visuose pasiekiamuose klausos įrenginiuose"</string>
    <string name="bluetooth_device_controls_title" msgid="1895676556354697234">"Klausos įrenginio nustatymai"</string>
    <string name="bluetooth_device_controls_summary" msgid="8115767735418425663">"Spartusis klavišas, klausos aparato suderinamumas"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Šiame įrenginyje"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Garso išvestis"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Apie garso išvestį"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Nukreipkite garsus į klausos įrenginį ar telefono garsiakalbį"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Susiję"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Skambėjimo tonas ir signalai"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Garsas vykstant skambučiams"</string>
    <string name="bluetooth_media_title" msgid="2878373577382067290">"Medijos ir sistemos garsai"</string>
    <string name="bluetooth_notification_title" msgid="8708962394926222039">"Pranešimai"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Pagal numatytuosius nustatymus garso išvestis nustatoma atsižvelgiant į atskiras programas"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"„Bluetooth“ įrenginys be pavadinimo"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Ieškoma"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Nerasta netol. esanč. „Bluetooth“ įreng."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"„Bluetooth“ susiejimo užklausa"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Susiejimo užklausa"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Palieskite, kad susietumėte su „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"„Bluetooth“ išjungtas"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Palieskite, kad įjungtumėte"</string>
    <string name="device_picker" msgid="2427027896389445414">"Pasirinkti „Bluetooth“ įrenginį"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"Programa „<xliff:g id="APP_NAME">%1$s</xliff:g>“ nori įjungti „Bluetooth“"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"Programa „<xliff:g id="APP_NAME">%1$s</xliff:g>“ nori išjungti „Bluetooth“"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Programa nori įjungti „Bluetooth“"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Programa nori išjungti „Bluetooth“"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Įjungiamas „Bluetooth“…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"„Bluetooth“ išjungiamas…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"„Bluetooth“ ryšio užklausa"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Prieigos prie telefonų knygos užklausa"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Prieigos prie pranešimų užklausa"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Kitiems įrenginiams matomas kaip „<xliff:g id="DEVICE_NAME">^1</xliff:g>“ įrenginys"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Įjunkite „Bluetooth“, kad galėtumėte susieti su kitais įrenginiais."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Jūsų įrenginiai"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Susieti naują įrenginį"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Išj. „Bluetooth“ A2DP apar. įr. iškelt."</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Išjungti „Bluetooth LE Audio“ aparatinės įrangos iškeltį"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Paleisti įrenginį iš naujo?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Turite paleisti įrenginį iš naujo, kad galėtumėte pakeisti šį nustatymą."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Paleisti iš naujo"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Atšaukti"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"„Bluetooth LE Audio“ išjungimas"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Jei įrenginys palaiko „LE Audio“ aparatinės įrangos galimybes, išjungiama funkcija „Bluetooth LE Audio“."</string>
    <string name="bluetooth_leaudio_mode" msgid="5206961943393400814">"„Bluetooth LE Audio“ režimas"</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Rodyti „LE Audio“ jungiklį įrenginio informacijoje"</string>
    <string name="bluetooth_bypass_leaudio_allowlist" msgid="7392319491894565552">"„Bluetooth LE Audio“ leidžiamųjų sąrašo išskyrimas"</string>
    <string name="bluetooth_bypass_leaudio_allowlist_summary" msgid="8999245286359656738">"Naudoti „LE Audio“ pagal numatytuosius nustatymus, net jei „LE Audio“ išorinis įrenginys nebuvo patvirtintas kaip atitinkantis leidžiamųjų sąrašo kriterijus."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Laikmenos"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Skambinimo įrenginiai"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Kiti įrenginiai"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Išsaugoti įrenginiai"</string>
    <string name="connected_device_fast_pair_device_title" msgid="543124539265592392">"Susieta su paskyra"</string>
    <string name="connected_device_previously_associated_fast_pair_device_title" msgid="8353405823992023457">"Anksčiau naudota su paskyra"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bus įjungtas „Bluetooth“, kad būtų galima susieti"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Ryšio nuostatos"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Anksčiau susieti"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"„Bluetooth“ įjungtas"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Žr. viską"</string>
    <string name="connected_device_fast_pair_device_see_all" msgid="4898279230458128620">"Žiūrėti viską"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Rašiklis"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Rašiklio mygtuko paspaudimas"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (darbo profilis)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Rašymas teksto laukuose"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Visų rašiklio mygtuko paspaudimų nepaisymas"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Rašiklis"</string>
    <string name="audio_sharing_title" msgid="4144157137502923821">"Garso bendrinimas"</string>
    <string name="audio_sharing_switch_title" msgid="7052827328670825701">"Bendrinti garsą"</string>
    <string name="calls_and_alarms_device_title" msgid="6993559028175454198">"Skambučiai ir signalai"</string>
    <string name="audio_streams_category_title" msgid="4878022761829895463">"Prisijungimas prie „LE Audio“ srauto"</string>
    <string name="audio_streams_pref_title" msgid="6320485086288646209">"Garso srautai netoliese"</string>
    <string name="audio_streams_title" msgid="6617990880383079165">"Garso srautai"</string>
    <string name="audio_streams_qr_code_summary" msgid="2838923349871884871">"Prisijunkite prie garso srauto naudodami QR kodą"</string>
    <string name="audio_streams_empty" msgid="8803517701437394982">"Netoliese nerasta jokių garso srautų."</string>
    <string name="date_and_time" msgid="1788358029823431692">"Data ir laikas"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Tarpinis serveris"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Išvalyti"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Tarpinio serverio prievadas"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Išjungti įgaliotąjį serverį, skirtą"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Atkurti numatytuosius nustatymus"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Atlikta"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Tarpinio serverio prieglobos pavadinimas"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Dėmesio"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"Gerai"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Įvestas prieglobos serverio pavadinimas netinkamas."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Į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="4250295137005082992">"Turite užpildyti prievado lauką."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Prievado laukas turi būti tuščias, jei tuščias prieglobos laukas."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Prievadas, kurį įvedėte, netinkamas."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"HTTP įgaliotąjį serverį naudoja naršyklė, bet jo negali naudoti kitos programos."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"PAC URL: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Ryšio patikros prieglobos serverio pavadinimas (www.google.com) „IPv4“:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"HTTP kliento bandymas:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Paleisti ryšio patikros bandymą"</string>
    <string name="skip_label" msgid="6380034601349015895">"Praleisti"</string>
    <string name="next_label" msgid="1248293387735652187">"Kitas"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Kalbos"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Pageidaujamų kalbų eiliškumas"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Sistemos kalba"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Pašalinti"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Pridėti kalbą"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Kalba"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Pageidaujama kalba"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Programų kalbos"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Nustatykite kiekvienos programos kalbą"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Programos kalba"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Siūlomos kalbos"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Visos kalbos"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Sistemos kalba"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Numatytoji sistemos vertė"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Šios programos kalbos pasirinkimas nepasiekiamas iš skilties „Nustatymai“."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Kalba gali skirtis nuo programoje pasiekiamų kalbų. Kai kuriose programose šis nustatymas gali būti nepalaikomas."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Nustatykite kiekvienos programos kalbą."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Jūsų sistema, programos ir svetainės naudoja pirmąją palaikomą kalbą iš pageidaujamų sąrašo."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Norėdami pasirinkti kalbą kiekvienai programai, eikite į programų kalbų nustatymus."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Sužinokite daugiau apie programos kalbas"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Pakeisti sistemos kalbą į %s ?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"Pridėti %s prie pageidaujamų kalbų?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"Tai nurodo programoms ir svetainėms, kad jūs taip pat teikiate pirmenybę šiai kalbai."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Pasikeis įrenginio nustatymai ir tinkamumo nustatymai pagal regioną."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Keisti"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s nepasiekiama"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Šios kalbos negalima naudoti kaip sistemos kalbos, bet programoms ir svetainėms nurodėte, kad teikiate pirmenybę šiai kalbai."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Tinkamumo nustatymai pagal regioną"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Nustatyti vienetus ir numerių nuostatas"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Leiskite programoms žinoti jūsų tinkamumo nustatymus pagal regioną, kad galėtų suasmeninti funkcijas."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Programos naudos jūsų tinkamumo nustatymus pagal regioną, kai bus galima."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatūra"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Pirma savaitės diena"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Skaičių nuostatos"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Naudoti numatytąjį"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celsijaus laipsnis (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Farenheito laipsnis (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Sekmadienis"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Pirmadienis"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Antradienis"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Trečiadienis"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Ketvirtadienis"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Penktadienis"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Šeštadienis"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Jei programa nepalaiko tinkamumo nustatymų pagal regioną, ji naudos savo numatytuosius lokalės nustatymus."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Sužinokite daugiau apie kalbos nuostatas."</string>
    <string name="category_title_terms_of_address" msgid="4309422700380895278">"Papildomos nuostatos"</string>
    <string name="terms_of_address_title" msgid="4064593634733842458">"Kreipimosi terminai"</string>
    <string name="terms_of_address_summary" msgid="6136134336560679144">"Nustatykite, kaip į jus kreiptis"</string>
    <string name="terms_of_address_intro_title" msgid="6149691509414243483">"Programose gali būti naudojami kreipimosi terminai, kad į jus būtų kreipiamasi suasmenintai."</string>
    <string name="terms_of_address_not_specified" msgid="4439257779351251973">"Nenurodyta"</string>
    <string name="terms_of_address_feminine" msgid="1743479869695539283">"Moteriškoji giminė"</string>
    <string name="terms_of_address_masculine" msgid="983106046135098856">"Vyriškoji giminė"</string>
    <string name="terms_of_address_neutral" msgid="5475414185543112478">"Neutralu"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Pašalinti pasirinktą kalbą?}one{Pašalinti pasirinktas kalbas?}few{Pašalinti pasirinktas kalbas?}many{Pašalinti pasirinktas kalbas?}other{Pašalinti pasirinktas kalbas?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Tekstas bus rodomas kita kalba."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Negalima pašalinti visų kalbų"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Palikite bent vieną pageidaujamą kalbą"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Nepasiekiama kaip sistemos kalba"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Perkelti aukštyn"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Perkelti žemyn"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Perkelti į viršų"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Perkelti į apačią"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Pašalinti kalbą"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Pasirinkti veiklą"</string>
    <string name="cancel" msgid="5780102414089664898">"Atšaukti"</string>
    <string name="okay" msgid="4827099303045669054">"Gerai"</string>
    <string name="forget" msgid="3754013654135912783">"Pamiršti"</string>
    <string name="save" msgid="3125033126936493822">"Išsaugoti"</string>
    <string name="done" msgid="7497982645646431310">"Atlikta"</string>
    <string name="apply" msgid="7834684883190163536">"Taikyti"</string>
    <string name="share" msgid="8502235338607613795">"Bendrinti"</string>
    <string name="add" msgid="8335206931421683426">"Pridėti"</string>
    <string name="remove" msgid="1028414219245072102">"Pašalinti"</string>
    <string name="settings_label" msgid="943294133671632976">"Nustatymai"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Nustatymai"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Spartusis nustatymų klavišas"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Lėktuvo režimas"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Belaidis ryšys ir tinklai"</string>
    <string name="roaming" msgid="3055365654530847985">"Tarptinklinis ryšys"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Veikiant tarptinkliniam ryšiui, prisijungti prie duomenų paslaugų"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Veikiant tarptinkliniam ryšiui, prisijungti prie duomenų paslaugų"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Gali būti taikomi tarptinklinio ryšio mokesčiai."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Nustatyti laiką automatiškai"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Nustatyti automatiškai"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Kai įjungtas šis perjungiklis, laiko juostai nustatyti naudojama vietovė"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Naudoti numatytuosius lokalės nustatymus"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Naudoti 24 val. formatą"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Laikas"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Laiko formatas"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Laiko juosta"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Laiko juosta"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Data"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Ieškokite regiono"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Regionas"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"UTC nuokrypio pasirinkimas"</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer_first_sentence" msgid="1326664252091302458">"Naudoti <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="SECOND_SENTENCE">%2$s</xliff:g>"</string>
    <string name="zone_info_footer_second_sentence" msgid="6472889173541729110">"<xliff:g id="DST_TIME_TYPE">%1$s</xliff:g> prasideda <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Naudojama: <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Vasaros laikas nenaudojamas."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Vasaros laikas"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standartinis laikas"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Pasirinkti pagal regioną"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Pasirinkti pagal UTC nuokrypį"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Užrakinti, kai baigiasi skirtasis ekrano laikas"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pasibaigus skirtajam laikui"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Iškart pasibaigus skirtajam laikui, išskyrus atvejus, kai „<xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>“ laiko jį atrakintą"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pasibaigus skirtajam laikui, išskyrus atvejus, kai „<xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>“ laiko jį atrakintą"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Teksto prid. užrakinimo ekrane"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Nėra"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Pvz., Tomo „Android“."</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Vietovė"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Naudoti vietovę"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Išjungti"</string>
    <string name="location_settings_summary_location_on" msgid="4273299717586679786">"{count,plural, =1{Įjungta / # programa gali pasiekti vietovę}one{Įjungta / # programa gali pasiekti vietovę}few{Įjungta / # programos gali pasiekti vietovę}many{Įjungta / # programos gali pasiekti vietovę}other{Įjungta / # programų gali pasiekti vietovę}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Įkeliama…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Programos, turinčios netoliese esančių įrenginių leidimą, gali nustatyti apytikslį atstumą iki prijungtų įrenginių."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Programų ir paslaugų prieiga prie vietovės išjungta. Įrenginio vietovės informacija vis tiek gali būti siunčiama pagalbos tarnyboms skambinant ar siunčiant teksto pranešimą pagalbos numeriu."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="349380666660145540">"Sužinokite daugiau apie vietovės nustatymus."</string>
    <string name="location_settings_tooltip_text_for_chrome" msgid="3574930966097093550">"Jei norite pakeisti prieigą prie vietovės, eikite į skiltį „Nustatymai“ &gt; „Sauga ir privatumas“ &gt; „Privatumo valdikliai“"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Paskyros"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Sauga"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Šifruotė ir prisijungimo duomenys"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Užrakinimo ekranas"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Ką rodyti"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Nepasiekiama"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Saugos būsena"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Ekrano užraktas, paslauga „Rasti įrenginį“, programos saugumas"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Sauga ir privatumas"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Programų saugumas, įrenginio užraktas, leidimai"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Veidas pridėtas"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Reikia nustatyti"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Atrakinimas pagal veidą"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Atrakinimas pagal veidą, skirtas darbo profiliui"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Kaip nustatyti atrakinimą pagal veidą"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Atrakinimo pagal veidą nustatymas"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Autentifikavimas naudojant veidą"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Pradėti"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Jei neįgaliesiems pritaikyta atrakinimo pagal veidą funkcija išjungta, kai kurie nustatymo veiksmai gali tinkamai neveikti su „TalkBack“."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Grįžti"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Tęsti sąranką"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Naud. pritaikymo neįgal. sąranką"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Atšaukti"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Ačiū, ne"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Sutinku"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Daugiau"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Atrakinimas naudojant veidą"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Atrakinimo pagal veidą leidimas"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Autentifikavimas naudojant veidą"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Atrakinkite telefoną ir patvirtinkite pirkimo operacijas veidu.\n\nPastaba: negalite atrakinti šio įrenginio veidu. Norėdami gauti daugiau informacijos, susisiekite su organizacijos administratoriumi."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Naudokite veidą, norėdami atrakinti telefoną, įgalioti pirkimo veiksmus arba prisijungti prie programų"</string>
    <string name="security_settings_face_enroll_introduction_info_title" msgid="7120796118179406944"></string>
    <string name="security_settings_face_enroll_introduction_info_glasses" msgid="2733870453868907471"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_glasses" msgid="6303917184145586880"></string>
    <string name="security_settings_face_enroll_introduction_how_title" msgid="3680193263037835600"></string>
    <string name="security_settings_face_enroll_introduction_control_title" msgid="4536951089583821051"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_title" msgid="5892729331412694759"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Veidas turi būti apskritimo centre"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Praleisti"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Pridėjote maksimalų skaičių veidų"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Negalima pridėti daugiau veidų"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Registracija neužbaigta"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"Gerai"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Pasiektas veido registracijos laiko apribojimas. Bandykite dar kartą."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Nepavyko užregistruoti veido."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Viskas nustatyta. Atrodo gerai."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Atlikta"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Atrakinimo pagal veidą našumo tobulinimas"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Atrakinimo pagal veidą nustatymas iš naujo"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Atrakinimo pagal veidą nustatymas iš naujo"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Patobulinkite saugumą ir našumą"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Atrakinimo pagal veidą nustatymas"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Kad galėtumėte iš naujo nustatyti atrakinimą pagal veidą, ištrinkite esamą veido modelį.\n\nVeido modelis bus visam laikui saugiai ištrintas.\n\nIštrynus, kad galėtumėte atrakinti telefoną ir nustatyti tapatybę programose, reikės PIN kodo, atrakinimo piešinio arba slaptažodžio."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Kad galėtumėte iš naujo nustatyti atrakinimą pagal veidą, ištrinkite esamą veido modelį.\n\nVeido modelis bus visam laikui saugiai ištrintas.\n\nIštrynus, kad galėtumėte atrakinti telefoną ir nustatyti tapatybę programose, reikės kontrolinio kodo, PIN kodo, atrakinimo piešinio arba slaptažodžio."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Atrakinimą pagal veidą naudoti su"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Kai naudojamas atrakinimas pagal veidą"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Reikia būti atsimerkus"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Norint atrakinti telefoną, reikia būti atsimerkus"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Visada reikalauti patvirtinimo"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Naudojant atrakinimą pagal veidą programose, visada reikalauti patvirtinimo"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Ištrinti veido modelį"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Nustatyti atrakinimą pagal veidą"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Ištrinti veido modelį?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Jūsų veido modelis bus visam laikui saugiai ištrintas.\n\nIštrynus reikės PIN kodo, atrakinimo piešinio arba slaptažodžio, norint atrakinti telefoną ar nustatyti tapatybę programose."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Jūsų veido modelis bus visam laikui saugiai ištrintas.\n\nIštrynus reikės PIN kodo, atrakinimo piešinio arba slaptažodžio, norint atrakinti telefoną."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Jūsų veido modelis bus visam laikui saugiai ištrintas.\n\nIštrynus reikės kontrolinio kodo, PIN kodo, atrakinimo piešinio arba slaptažodžio, norint atrakinti telefoną ar nustatyti tapatybę programose."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Jūsų veido modelis bus visam laikui saugiai ištrintas.\n\nIštrynus reikės piršto atspaudo, PIN kodo, atrakinimo piešinio arba slaptažodžio, norint atrakinti telefoną."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Naudokite atrakinimo pagal veidą funkciją, kad atrakintumėte telefoną"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Piršto antspaudas"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Kontr. kodo jutiklis"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Naudojant atrakinimą piršto atspaudu"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Kontrol. kodas darbui"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Pridėti piršto atspaudą"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Pridėtas piršto atspaudas}one{Pridėtas # piršto atspaudas}few{Pridėti # piršto atspaudai}many{Pridėta # piršto atspaudo}other{Pridėta # piršto atspaudų}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Reikia nustatyti"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Kontrolinio kodo nustatymas"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Atrakinimo kontroliniu kodu leidimas"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Piršto antspaudo naudojimas"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Sužinokite daugiau apie atrakinimą piršto atspaudu"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Jūs viską valdote"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Viską valdote jūs ir jūsų vaikas"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Atminkite"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Atrakinkite telefoną ir patvirtinkite pirkimo operacijas piršto atspaudu.\n\nPastaba: negalite atrakinti šio įrenginio piršto atspaudu. Norėdami gauti daugiau informacijos, susisiekite su organizacijos administratoriumi."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Atšaukti"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Ne, ačiū"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Sutinku"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Praleisti piršto antspaudą?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Piršto antspaudo sąranka užtrunka tik minutę ar dvi. Jei praleisite šį veiksmą, vėliau piršto antspaudą galėsite pridėti nustatymuose."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Kai rodoma ši piktograma, tapatybei nustatyti naudokite kontrolinį kodą, kaip prisijungdami prie programų ar patvirtindami pirkinį"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Atminkite"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Kaip tai veikia"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Naudojant atrakinimą piršto atspaudu kuriamas unikalus jūsų piršto atspaudo modelis, kad būtų galima patvirtinti jūsų tapatybę. Kad sukurtumėte šį piršto atspaudo modelį nustatydami, turite sukurti kontrolinio kodo vaizdų iš skirtingų pozicijų."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Naudojant atrakinimą kontroliniu kodu kuriamas unikalus jūsų vaiko kontrolinio kodo modelis, kad būtų galima patvirtinti vaiko tapatybę. Norint sukurti šį kontrolinio kodo modelį nustatant, reikia sukurti kontrolinio kodo vaizdų iš skirtingų pozicijų."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Kad pasiektumėte geriausių rezultatų, naudokite „Made for Google“ sertifikuotą apsauginį ekrano stiklą. Naudojant kitus apsauginius ekrano stiklus piršto atspaudas gali neveikti."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Kad pasiektumėte geriausių rezultatų, naudokite „Made for Google“ sertifikuotą apsauginį ekrano stiklą. Naudojant kitus apsauginius ekrano stiklus vaiko kontrolinis kodas gali neveikti."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Laikrodžio atrakinimas"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="5032953826653108646">"Jei nustatote atrakinimą pagal veidą ir atrakinimą piršto atspaudu, telefone prašoma piršto atspaudo, kai dėvite kaukę arba esate tamsioje vietoje.\n\nLaikrodžio atrakinimo funkcija yra dar vienas patogus būdas atrakinti telefoną, pvz., kai jūsų pirštai šlapi arba kai nepavyksta atpažinti jūsų veido."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="5881355884547769337">"Laikrodžio atrakinimo funkcija yra dar vienas patogus būdas atrakinti telefoną, pvz., kai nepavyksta atpažinti jūsų piršto atspaudo."</string>
    <string name="biometric_settings_intro_with_face" msgid="7671919122230588521">"Laikrodžio atrakinimo funkcija yra dar vienas patogus būdas atrakinti telefoną, pvz., kai nepavyksta atpažinti jūsų veido"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Naudokite piršto atspaudą arba laikrodį toliau nurodytiems veiksmams atlikti."</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Naudokite veidą arba laikrodį toliau nurodytiems veiksmams atlikti."</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Naudokite veidą, piršto atspaudą arba laikrodį toliau nurodytiems veiksmams atlikti."</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Naudokite laikrodį toliau nurodytiems veiksmams atlikti."</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Pagal veidą arba laikrodžiu"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Pagal piršto atspaudą arba laikrodžiu"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Pagal veidą, piršto atspaudą arba laikrodžiu"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Laikrodžiu"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Pirmiausia atrakinimas pagal veidą arba piršto atspaudu"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Jei nepavyksta jūsų atpažinti pagal veidą ar piršto atspaudą, galite atrakinti naudodami laikrodį"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Pirmiausia atrakinimas piršto atspaudu"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Jei nepavyksta jūsų atpažinti pagal piršto atspaudą, galite atrakinti naudodami laikrodį"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Pirmiausia atrakinimas pagal veidą"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Jei nepavyksta jūsų atpažinti pagal veidą, galite atrakinti naudodami laikrodį"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Nustatyti"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Pridėti piršto atspaudo ir <xliff:g id="WATCH">%s</xliff:g> duomenys"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Pridėti piršto atspaudų ir <xliff:g id="WATCH">%s</xliff:g> duomenys"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Pridėti veido ir <xliff:g id="WATCH">%s</xliff:g> duomenys"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Pridėti veido, piršto atspaudo ir <xliff:g id="WATCH">%s</xliff:g> duomenys"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Pridėti veido, piršto atspaudų ir <xliff:g id="WATCH">%s</xliff:g> duomenys"</string>
    <string name="security_settings_remoteauth_preference_title" msgid="8319680328086089533">"Nuotolinės Autentifikavimo priemonės atrakinimas"</string>
    <string name="security_settings_remoteauth_preference_summary" msgid="1507004469316635196">"Laikrodis pridėtas"</string>
    <string name="security_settings_remoteauth_enroll_introduction_title" msgid="2151004795778999671">"Nustatykite laikrodį"</string>
    <string name="security_settings_remoteauth_enroll_introduction_message" msgid="8737276885766036074">"Laikrodžio atrakinimo funkcija yra dar vienas patogus būdas atrakinti šį telefoną, pvz., kai jūsų pirštai šlapi arba kai nepavyksta atpažinti jūsų veido.\n\nGalite atrakinti šį telefoną naudodami laikrodį, atlikę toliau nurodytus veiksmus."</string>
    <string name="security_settings_remoteauth_enroll_introduction_disagree" msgid="7639258097401796028">"Ne dabar"</string>
    <string name="security_settings_remoteauth_enroll_introduction_agree" msgid="5271119227172049339">"Tęsti"</string>
    <string name="security_settings_remoteauth_enroll_introduction_more" msgid="1644105894631257595">"Daugiau"</string>
    <string name="security_settings_remoteauth_enroll_introduction_how_title" msgid="6604152528267830349">"Kaip tai veikia"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open" msgid="8570511335628725116">"Laikrodis turi būti atrakintas, uždėtas ant riešo ir netoli šio telefono. Kol laikrodis bus ant riešo, nereikės jo iš naujo atrakinti."</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications" msgid="4298855831154039694">"Kai šis telefonas bus atrakintas, gausite pranešimą laikrodyje. Jei telefonas atrakinamas, nors nenorėjote to padaryti, palieskite pranešimą vėl užrakinti telefoną."</string>
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title" msgid="7974976673323638524">"Viską valdote jūs"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch" msgid="1888318677088986801">"Galite bet kada atšaukti laikrodžio funkciją „Laikrodžio atrakinimas“ skiltyje „Nustatymai“"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification" msgid="1597397399097952974">"Palieskite pranešimą"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up" msgid="2129230804324634653">"Perbraukite aukštyn užrakinimo ekrane"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_title" msgid="313016997943607675">"Laikrodžio pasirinkimas"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading" msgid="8227585438932911013">"Pasiekiami laikrodžiai"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_disagree" msgid="1670201454188049863">"Atšaukti"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_agree" msgid="7048336252635730908">"Patvirtinti"</string>
    <string name="security_settings_remoteauth_enroll_finish_title" msgid="3807372930755413112">"Viskas nustatyta!"</string>
    <string name="security_settings_remoteauth_enroll_finish_description" msgid="4876209907275244653">"Dabar galite atrakinti šį telefoną naudodami laikrodį, perbraukę aukštyn užrakinimo ekrane arba palietę pranešimą"</string>
    <string name="security_settings_remoteauth_enroll_finish_btn_next" msgid="8072138423143889592">"Atlikta"</string>
    <string name="security_settings_remoteauth_settings_title" msgid="1564912618737165129">"Laikrodžio atrakinimas"</string>
    <string name="security_settings_remoteauth_settings_description" msgid="2758239650119457964">"Galite atrakinti šį telefoną naudodami laikrodį, perbraukę aukštyn užrakinimo ekrane arba palietę pranešimą"</string>
    <string name="security_settings_remoteauth_settings_info_footer" msgid="795894033901478120">"Kad galėtumėte naudoti Laikrodžio atrakinimo funkciją, laikrodis turi būti atrakintas, uždėtas ant riešo, netoli šio telefono ir prie jo prijungtas. Jei ryšys bus pertrauktas, turėsite atrakinti telefoną, kad galėtumėte naudoti Laikrodžio atrakinimo funkciją.\n\nAtminkite\nVienu metu galite turėti tik vieną susietą laikrodį. Jei norite pridėti kitą laikrodį, pirmiausia pašalinkite esamą."</string>
    <string name="security_settings_remoteauth_settings_learn_more" msgid="5653556124819260050">"Sužinokite daugiau apie funkciją „Laikrodžio atrakinimas“"</string>
    <string name="security_settings_remoteauth_settings_register_new_authenticator" msgid="9191331738306527887">"Pridėti laikrodį"</string>
    <string name="security_settings_remoteauth_settings_remove_device" msgid="2436226120578851282">"Pašalinti laikrodį"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Piršto atspaudas ir atrakinimas pagal veidą"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Atrakinimas pagal veidą ir piršto atspaudu darbe"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Reikia nustatyti"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Pridėtas veidas ir kontroliniai kodai"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Pridėtas veidas ir kontrolinis kodas"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Jei nustatote atrakinimą pagal veidą ir atrakinimą piršto atspaudu, telefone prašoma piršto atspaudo, kai dėvite kaukę arba esate tamsioje vietoje"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Atrakinimo metodai"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Naudoti veido atpažinimą arba piršto atspaudą"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Atrakinti telefoną"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Patvirtinti tapatybę programose"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Veido atpažinimo naudojimas"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Kontrolinio kodo naudojimas"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Veido atpažinimo ar piršto atspaudo naudojimas"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"Gerai"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Nepavyksta nustatyti atrakinimo pagal veidą"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Išeikite iš išskaidyto ekrano režimo, kad nustatytumėte atrakinimą pagal veidą"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Nepavyko nustatyti piršto atspaudo"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Išeikite iš išskaidyto ekrano režimo, kad nustatytumėte atrakinimą piršto atspaudu"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"Gerai"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Praleisti ekrano užraktą?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Vis tiek praleisti"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Grįžti"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Praleisti"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Atšaukti"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Palieskite jutiklį"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Palieskite maitinimo mygtuką jo nespausdami"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Kaip nustatyti piršto atspaudą"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Jis yra telefono užpakalinėje dalyje. Naudokite smilių."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Piršto atspaudo jutiklis yra jūsų ekrane. Piršto atspaudą užfiksuosite kitame ekrane."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Pradėti"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Raskite jutiklį pirštu braukdami per ekraną. Palieskite ir palaikykite piršto atspaudo jutiklį."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Įrenginio ir piršto antspaudo jutiklio vietos iliustracija"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Pavadinimas"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"Gerai"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Bandyti dar kartą"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Ištrinti"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Palieskite jutiklį"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Uždėkite pirštą ant jutiklio ir pakelkite, kai pajusite vibravimą"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Laikykite pirštą prispaustą prie jutiklio, kol pajusite vibraciją"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Nespausdami mygtuko laikykite kontrolinį kodą ant jutiklio, kol pajusite vibravimą.\n\nKaskart šiek tiek pajudinkite pirštą. Taip užfiksuojama daugiau kontrolinio kodo."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Palieskite ir palaikykite piršto atspaudo jutiklį"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Patraukite ir vėl prilieskite"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Dar kartą"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Stebėkite kontrolinio kodo piktogramą"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Vis patraukite pirštą, kad pridėtumėte skirtingas piršto atspaudo dalis"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Palieskite ir palaikykite kiekvieną kartą, kai kontrolinio kodo piktograma sujuda. Taip užfiksuojama daugiau piršto atspaudo"</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Padėkite piršto galiuką ant jutiklio"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Palieskite kairiąja piršto dalimi"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Palieskite dešiniąja piršto dalimi"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Palieskite jutiklį viduriniąja piršto dalimi"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Palieskite jutiklį piršto galiuku"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Palieskite jutiklį kairiąja piršto dalimi"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Galiausiai palieskite jutiklį dešiniąja piršto dalimi"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Padėkite vieną piršto šoną ant jutiklio ir palaikykite, tada tą patį atlikite su kitu šonu"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Taip užfiksuojama daugiau piršto atspaudo"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Registracija kontroliniu kodu: <xliff:g id="PERCENTAGE">%d</xliff:g> proc."</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Užregistruota <xliff:g id="PERCENTAGE">%d</xliff:g> proc."</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Registracija kontroliniu kodu: <xliff:g id="PERCENTAGE">%d</xliff:g> proc."</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Piršto atspaudas pridėtas"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Palieskite, kad bet kada atrakintumėte"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Palieskite jutiklį, kad atrakintumėte, net kai ekranas išjungtas. Tai padidina atsitiktinio atrakinimo tikimybę."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Ekranas, atrakinti"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Atlikti vėliau"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Patraukite ir vėl prilieskite"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Padėkite vieną piršto šoną ant jutiklio ir palaikykite, tada tą patį atlikite su kitu šonu"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Praleisti pirštų atspaudų nustatymą?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Pasirinkote naudoti piršto atspaudą kaip vieną iš telefono atrakinimo būdų. Jei praleisite dabar, turėsite nustatyti funkciją vėliau. Nustatymas apytiksliai užtruks tik minutę."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Praleisti nustatymo „<xliff:g id="OPTIONS">%s</xliff:g>“ sąranką?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Praleisti PIN kodo sąranką?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Praleisti PIN kodo ir veido nustatymą?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Praleisti PIN kodo ir kontrolinio kodo nustatymą?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Praleisti PIN kodo, veido ir kontrolinio kodo nustatymą?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Praleisti slaptažodžio sąranką?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Praleisti slaptažodžio ir veido nustatymą?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Praleisti slaptažodžio ir kontrolinio kodo nustatymą?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Praleisti slaptažodžio, veido ir kontrolinio kodo nustatymą?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Praleisti atrakinimo piešinio sąranką?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Praleisti atrakinimo piešinio ir veido nustatymą?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Praleisti atrakinimo piešinio ir kontrolinio kodo nustatymą?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Praleisti atrakinimo piešinio, veido ir kontrolinio kodo nustatymą?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Nustatyti ekrano užraktą"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Atlikta"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Oi, tai ne jutiklis"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Smiliumi palieskite jutiklį tel. užp. dalyje."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Nepavyko užbaigti piršto atspaudo sąrankos"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Galite bandyti dar kartą dabar arba vėliau nustatykite piršto atspaudą skiltyje „Nustatymai“."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Galite bandyti dar kartą dabar arba vėliau nustatykite piršto atspaudą."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Baigėsi piršto atspaudo sąrankos skirtasis laikas"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Piršto atspaudą galite nustatyti vėliau skiltyje „Nustatymai“."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Kažkas nepavyko. Piršto atspaudą galite nustatyti vėliau skiltyje „Nustatymai“."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Piršto atspaudą galite nustatyti vėliau."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Kažkas nepavyko. Piršto atspaudą galite nustatyti vėliau."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Pridėti kitą"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Kitas"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Ekrano užrakto parinktis išjungta. Jei norite sužinoti daugiau, susisiekite su savo organizacijos administratoriumi."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Vis tiek galite naudoti kontrolinį kodą pirkimo operacijoms įgalioti ir programoms pasiekti."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Patraukite pirštą, tada vėl palieskite jutiklį"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Negalima naudoti piršto atspaudo jutiklio"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Apsilankykite pas taisymo paslaugos teikėją."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Daugiau saugos nustatymų"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Darbo profilio užraktas, šifruotė ir kt."</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Šifruotė, prisijungimo duomenys ir kt."</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"sauga, daugiau saugos nustatymų, daugiau nustatymų, išplėstiniai saugos nustatymai"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Daugiau privatumo nustatymų"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Geresnė sauga ir privatumas"</string>
    <string name="security_header" msgid="961514795852103424">"Sauga"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Privatumas"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Darbo profilis"</string>
    <string name="private_space_title" msgid="1752064212078238723">"Privati erdvė"</string>
    <string name="private_space_summary" msgid="2274405892301976238">"Privačių programų užrakinimas ir slėpimas"</string>
    <string name="private_space_description" msgid="4059594203775816136">"Laikykite privačias programas atskiroje erdvėje, kurią galite slėpti ar užrakinti"</string>
    <string name="private_space_lock_title" msgid="7230836881433350526">"Privačios erdvės užraktas"</string>
    <string name="private_space_one_lock_summary" msgid="2106513606571219068">"Galite atrakinti privačią erdvę taip pat, kaip atrakinate įrenginį, arba pasirinkti kitą užraktą"</string>
    <string name="private_space_screen_lock_title" msgid="8679383894967823163">"Įrenginio ekrano užrakto naudojimas"</string>
    <string name="private_space_biometric_title" msgid="3934339826674553174">"Atrakinimas pagal veidą ir piršto atspaudu"</string>
    <string name="private_space_fingerprint_title" msgid="5989254643211889931">"Atrakinimas piršto atspaudu"</string>
    <string name="private_space_face_title" msgid="3290402865367663079">"Atrakinimas pagal veidą"</string>
    <string name="private_space_biometric_summary" msgid="4403837276018724581">"Palieskite, kad atliktumėte sąranką"</string>
    <string name="private_space_fingerprint_unlock_title" msgid="3614016453395789051">"Privačios erdvės atrakinimas piršto atspaudu"</string>
    <string name="private_space_face_unlock_title" msgid="462248384776453613">"Privačios erdvės atrakinimas pagal veidą"</string>
    <string name="private_space_category_ways_to_unlock" msgid="4356631225316950046">"Atrakinimo metodai"</string>
    <string name="private_space_screen_lock_summary" msgid="394837965365561070">"Toks pats kaip įrenginio ekrano užraktas"</string>
    <string name="private_space_new_lock_title" msgid="9056139964133004094">"Pasirinkti naują privačios erdvės užraktą?"</string>
    <string name="private_space_auto_lock_title" msgid="8663409382910601261">"Užrakinti privačią erdvę automatiškai"</string>
    <string name="private_space_auto_lock_page_summary" msgid="8679844515655838654">"Galite automatiškai užrakinti privačią erdvę, jei tam tikrą laikotarpį nenaudojote įrenginio"</string>
    <string name="private_space_auto_lock_every_time" msgid="1215061855836002830">"Kaskart, kai įrenginys užrakinamas"</string>
    <string name="private_space_auto_lock_after_inactivity" msgid="1748673030841528649">"Po penkių neaktyvumo minučių"</string>
    <string name="private_space_auto_lock_never" msgid="595014527119778873">"Niekada"</string>
    <string name="private_space_hide_title" msgid="8687034008994037610">"Slėpimas užrakinus"</string>
    <string name="privatespace_hide_page_title" msgid="8417507414027827566">"Užrakintos privačios erdvės slėpimas"</string>
    <string name="privatespace_hide_page_summary" msgid="5525422595477989312">"Jei nenorite, kad kiti žmonės žinotų, jog turite privačią erdvę savo įrenginyje, galite slėpti ją programų sąraše"</string>
    <string name="privatespace_access_header" msgid="6066826215718835041">"Prieiga prie paslėptos privačios erdvės"</string>
    <string name="privatespace_search_description" msgid="3121043205513022357">"Programų sąrašo paieškos juostoje įveskite „privati erdvė“"</string>
    <string name="privatespace_tap_tile_description" msgid="8346440188590931635">"Palieskite privačios erdvės išklotinės elementą"</string>
    <string name="privatespace_unlock_description" msgid="3177710543121916413">"Atrakinti privačią erdvę"</string>
    <string name="privatespace_hide_off_summary" msgid="7227778747159633671">"Išjungti"</string>
    <string name="privatespace_hide_on_summary" msgid="6136704537527640183">"Įjungti"</string>
    <string name="private_space_category_system" msgid="1286843321867285700">"Sistema"</string>
    <string name="private_space_delete_title" msgid="636873505724100006">"Ištrinti privačią erdvę"</string>
    <string name="private_space_delete_header" msgid="4594429153176776184">"Ištrinti privačią erdvę?"</string>
    <string name="private_space_delete_summary" msgid="3344372988408565545">"Jūsų privati erdvė bus pašalinta iš įrenginio. Visos privačios programos ir duomenys bus ištrinti. Negalite anuliuoti šio veiksmo."</string>
    <string name="private_space_accounts" msgid="1078277762792056395">"Toliau nurodytos paskyros bus pašalintos iš jūsų privačios erdvės."</string>
    <string name="private_space_delete_button_label" msgid="1256981385318225002">"Ištrinti"</string>
    <string name="private_space_confirm_deletion_header" msgid="3468651585498942977">"Ištrinama privati erdvė…"</string>
    <string name="private_space_confirm_deletion_summary" msgid="342544588554284686">"Tai užtruks kelias akimirkas"</string>
    <string name="private_space_deleted" msgid="7692240901492540053">"Privati erdvė ištrinta"</string>
    <string name="private_space_delete_failed" msgid="7705795653796174741">"Nepavyko ištrinti privačios erdvės"</string>
    <string name="private_space_unlocked" msgid="9091600948712932046">"Privati erdvė atrakinta"</string>
    <string name="no_device_lock_title" msgid="1078223464721029954">"Nustatykite ekrano užraktą"</string>
    <string name="no_device_lock_summary" msgid="7436025227616244687">"Jei norite naudoti privačią erdvę, nustatykite ekrano užraktą šiame įrenginyje"</string>
    <string name="no_device_lock_action_label" msgid="2640487005629001288">"Ekrano užrakto nustatymas"</string>
    <string name="no_device_lock_cancel" msgid="4412602160321228863">"Atšaukti"</string>
    <string name="private_space_cancel_label" msgid="379259667396956886">"Atšaukti"</string>
    <string name="private_space_setup_button_label" msgid="2094882154623560585">"Nustatyti"</string>
    <string name="private_space_setup_title" msgid="7091257695872833671">"Privačios erdvės nustatymas"</string>
    <string name="private_space_hide_apps_summary" msgid="6272406822568588610">"Laikykite privačias programas atskiroje erdvėje, kurią galite slėpti ar užrakinti"</string>
    <string name="private_space_how_title" msgid="6878224242661347658">"Kaip tai veikia"</string>
    <string name="private_space_access_bottom_text" msgid="8931773427017046981">"Privačią erdvę galite pasiekti iš programų sąrašo apačios"</string>
    <string name="private_space_protected_lock_text" msgid="3926344387256377994">"Programos privačioje erdvėje saugomos jas užrakinant"</string>
    <string name="private_space_hidden_notifications_text" msgid="1487992156742340621">"Pranešimai iš programų privačioje erdvėje slepiami, kai ji užrakinta"</string>
    <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Programos privačioje erdvėje nebus rodomos leidimų tvarkytuvėje, privatumo informacijos suvestinėje ir kituose nustatymuose, kai privati erdvė bus užrakinta.\n\nPrivačios erdvės negalima perkelti į naują įrenginį. Turėsite nustatyti kitą privačią erdvę, jei norėsite ją naudoti kitame įrenginyje.\n\nBet kuris naudotojas, prijungęs jūsų įrenginį prie kompiuterio ar įdiegęs žalingų programų įrenginyje, galės pasiekti jūsų privačią erdvę."</string>
    <string name="private_space_setting_up_text" msgid="8458035555212009528">"Nustatoma privati erdvė…"</string>
    <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Pranešimai iš privačios erdvės programų slepiami, kai ji užrakinta"</string>
    <string name="private_space_share_photos_title" msgid="5176346349303364657">"Nuotraukų arba failų bendrinimas atrakinus privačią erdvę"</string>
    <string name="private_space_apps_installed_title" msgid="2428207301009983268">"Kai kurios programos jau įdiegtos privačioje erdvėje"</string>
    <string name="private_space_error_screen_title" msgid="739381738044418346">"Nepavyko nustatyti privačios erdvės"</string>
    <string name="private_space_tryagain_label" msgid="8305362615231738367">"Bandyti dar kartą"</string>
    <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Naudoti ekrano užraktą privačiai erdvei atrakinti?"</string>
    <string name="private_space_lockscreen_summary" msgid="430569465080645805">"Galite atrakinti privačią erdvę taip pat, kaip atrakinate įrenginį, arba pasirinkti kitą užraktą"</string>
    <string name="private_space_use_screenlock_label" msgid="9182153443192032782">"Naudoti ekrano užraktą"</string>
    <string name="private_space_set_lock_label" msgid="1790408277477408475">"Pasirinkti naują užraktą"</string>
    <string name="private_space_success_title" msgid="4351904015352046118">"Viskas nustatyta!"</string>
    <string name="private_space_access_text" msgid="4433988836344567888">"Jei norite rasti privačią erdvę, eikite į programų sąrašą, tada slinkite žemyn"</string>
    <string name="private_space_done_label" msgid="1020482651595246071">"Atlikta"</string>
    <string name="private_space_scrolldown_to_access" msgid="4820954877349434545">"Slinkite žemyn, kad surastumėte privačią erdvę"</string>
    <string name="private_space_retry_signin_title" msgid="8090276618867918844">"Prisijungti"</string>
    <string name="private_space_retry_summary" msgid="1920444015972648774">"Prisijunkite prie paskyros, kad galėtumėte naudoti su privačia erdve"</string>
    <string name="private_space_skip_login_label" msgid="7078019409056628192">"Ne dabar"</string>
    <string name="private_space_continue_login_label" msgid="7779965766333065391">"Tęsti"</string>
    <string name="private_space_lock_setup_title" msgid="6541564212199510787">"Privačios erdvės užrakto pasirinkimas"</string>
    <string name="private_space_lock_setup_description" msgid="423405593476300918">"Privačią erdvę galite atrakinti piršto atspaudu. Saugos sumetimais, įgalinus šią parinktį, reikia naudoti atsarginį užraktą."</string>
    <string name="private_space_choose_your_pin_header" msgid="4560802934975898265">"Privačios erdvės PIN kodo nustatymas"</string>
    <string name="private_space_choose_your_password_header" msgid="7660259341095044434">"Privačios erdvės slaptažodžio nustatymas"</string>
    <string name="private_space_choose_your_pattern_header" msgid="2165607102459936724">"Privačios erdvės atrakinimo piešinio nustatymas"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Galite pridėti iki <xliff:g id="COUNT">%d</xliff:g> piršto ats."</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Pridėjote maksimalų skaičių kontrolinių kodų"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Negalima pridėti daugiau kontrolinių kodų"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Ištrinti „<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>“"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Negalėsite naudoti kontrolinio kodo, kad atrakintumėte darbo profilį, įgaliotumėte pirkimo operacijas ar prisijungtumėte prie darbo programų."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Šifruotė"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Šifruota"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Ekrano užrakto nustatymas"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Papildomai saugai užtikrinti nustatykite šio įrenginio PIN kodą, atrakinimo piešinį arba slaptažodį."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Nustatykite ekrano užraktą"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Nustatykite ekrano užraktą"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Papildomai saugai užtikrinti nustatykite PIN kodą, atrakinimo piešinį arba slaptažodį."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Apsaugokite telefoną"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Įtraukite kontrolinį atrakinimo kodą"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Pasir. ekrano užrak."</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Pasirinkite ekrano užraktą"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Pasir. naują ekr. užraktą"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Pasir. darbo progr. užraktą"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Pasir. naują darbo užraktą"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Kad dar labiau apsaugotumėte įrenginį, nustatykite atsarginį ekrano užraktą"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Pasirinkite atsarginį ekrano užrakto metodą"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Jei pamiršite ekrano užraktą, IT administratorius negalės nustatyti jo iš naujo."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Nustatykite atskirą darbo užraktą"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Jei pamiršite šį užraktą, galėsite paprašyti IT administr. nustatyti jį iš naujo"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Ekrano užrakto parinktys"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Ekrano užrakto parinktys"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Atrakinimas automatiškai patvirtinus"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Atrakinkite automatiškai įvedę tinkamą ne mažiau kaip šešių skaitmenų PIN kodą. Tai ne taip saugu kaip patvirtinimas palietus „Enter“."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Automatiškai patvirtinti tinkamą PIN kodą"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"PIN kodo patvirtinimo paliečiant „Enter“ procesas gerokai saugesnis nei naudojant automatinį patvirtinimą"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Įveskite įrenginio PIN kodą, kad įjungtumėte automatinį patvirtinimą"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Įveskite įrenginio PIN kodą, kad išjungtumėte automatinį patvirtinimą"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Ekrano užraktas"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Darbo prof. užraktas"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Nėra"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Perbraukti"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Piešinys"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Slaptažodis"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Ne dabar"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Esamas ekrano užraktas"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Atrakinimo piešinys • Piršto atspaudas"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN kodas • Piršto atspaudas"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Slaptažodis • Piršto atspaudas"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Tęsti be piršto antspaudo"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Atrakinimo piešinys • Veido atpažinimas"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN kodas • Veido atpažinimas"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Slaptažodis • Veido atpažinimas"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Tęsti nenaudojant atrakinimo pagal veidą"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Tęsti be piršto atspaudo ar atpažinimo pagal veidą"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Nėra"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Perbraukti"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Piešinys"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN kodas"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Slaptažodis"</string>
    <string name="unlock_disable_frp_warning_title" msgid="2545569051372893686">"Pašalinti visų tipų įrenginio atrakinimą?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Pašalinti profilio apsaugą?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Atrakinimo piešinys apsaugo pamestą ar pavogtą telefoną"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Atrakinimo piešinys apsaugo pamestą ar pavogtą telefoną.<xliff:g id="EMPTY_LINE">

</xliff:g>Be to, įrenginyje ištrinamas išsaugotas kontrolinio kodo modelis. Negalėsite naudoti kontrolinio kodo tapatybei nustatyti programose."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Atrakinimo piešinys apsaugo pamestą ar pavogtą telefoną.<xliff:g id="EMPTY_LINE">

</xliff:g>Be to, jūsų veido modelis bus visam laikui saugiai ištrintas. Negalėsite naudoti veido tapatybei nustatyti programose."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Atrakinimo piešinys apsaugo pamestą ar pavogtą telefoną.<xliff:g id="EMPTY_LINE">

</xliff:g>Įrenginyje išsaugotas kontrolinio kodo modelis ištrinamas. Be to, jūsų veido modelis bus visam laikui saugiai ištrintas. Negalėsite naudoti veido ar kontrolinio kodo tapatybei nustatyti programose."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"PIN kodas apsaugo pamestą ar pavogtą telefoną"</string>
    <string name="unlock_disable_frp_warning_content_pin_authbound_keys" msgid="6497861740382402784">"Prarasite išsaugotus duomenis, pvz., PIN kodą.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Kortelės, nustatytos mokėti bekontakčiu būdu, bus pašalintos.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Piniginės ir kitos programos, kurioms reikia atrakinti įrenginį, gali tinkamai neveikti."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"PIN kodas apsaugo pamestą ar pavogtą telefoną.<xliff:g id="EMPTY_LINE">

</xliff:g>Be to, įrenginyje ištrinamas išsaugotas kontrolinio kodo modelis. Negalėsite naudoti kontrolinio kodo tapatybei nustatyti programose."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_authbound_keys" msgid="8930057076658360799">"Prarasite išsaugotus duomenis, pvz., PIN kodą ir piršto atspaudo modelį.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Kortelės, nustatytos mokėti bekontakčiu būdu, bus pašalintos.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Piniginės ir kitos programos, kurioms reikia atrakinti įrenginį, gali tinkamai neveikti."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"PIN kodas apsaugo pamestą ar pavogtą telefoną.<xliff:g id="EMPTY_LINE">

</xliff:g>Be to, jūsų veido modelis bus visam laikui saugiai ištrintas. Negalėsite naudoti veido tapatybei nustatyti programose."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_authbound_keys" msgid="979399855891561038">"Prarasite išsaugotus duomenis, pvz., PIN kodą ir veido modelį.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Kortelės, nustatytos mokėti bekontakčiu būdu, bus pašalintos.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Piniginės ir kitos programos, kurioms reikia atrakinti įrenginį, gali tinkamai neveikti."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"PIN kodas apsaugo pamestą ar pavogtą telefoną.<xliff:g id="EMPTY_LINE">

</xliff:g>Įrenginyje išsaugotas kontrolinio kodo modelis ištrinamas. Be to, jūsų veido modelis bus visam laikui saugiai ištrintas. Negalėsite naudoti veido ar kontrolinio kodo tapatybei nustatyti programose."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint_authbound_keys" msgid="7019955731206729909">"Prarasite išsaugotus duomenis, pvz., PIN kodą, veido ir piršto atspaudo modelius.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Kortelės, nustatytos mokėti bekontakčiu būdu, bus pašalintos.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Piniginės ir kitos programos, kurioms reikia atrakinti įrenginį, gali tinkamai neveikti."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Slaptažodis apsaugo pamestą ar pavogtą telefoną"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Slaptažodis apsaugo pamestą ar pavogtą telefoną.<xliff:g id="EMPTY_LINE">

</xliff:g>Be to, įrenginyje ištrinamas išsaugotas kontrolinio kodo modelis. Negalėsite naudoti kontrolinio kodo tapatybei nustatyti programose."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Slaptažodis apsaugo pamestą ar pavogtą telefoną.<xliff:g id="EMPTY_LINE">

</xliff:g>Be to, jūsų veido modelis bus visam laikui saugiai ištrintas. Negalėsite naudoti veido tapatybei nustatyti programose."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Slaptažodis apsaugo pamestą ar pavogtą telefoną.<xliff:g id="EMPTY_LINE">

</xliff:g>Įrenginyje išsaugotas kontrolinio kodo modelis ištrinamas. Be to, jūsų veido modelis bus visam laikui saugiai ištrintas. Negalėsite naudoti veido ar kontrolinio kodo tapatybei nustatyti programose."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Įrenginio apsaugos funkcijos neveiks be ekrano užrakto."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Įrenginio apsaugos funkcijos neveiks be ekrano užrakto.<xliff:g id="EMPTY_LINE">

</xliff:g>Be to, įrenginyje ištrinamas išsaugotas kontrolinio kodo modelis. Negalėsite naudoti kontrolinio kodo tapatybei nustatyti programose."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Įrenginio apsaugos funkcijos neveiks be ekrano užrakto.<xliff:g id="EMPTY_LINE">

</xliff:g>Be to, jūsų veido modelis bus visam laikui saugiai ištrintas. Negalėsite naudoti veido tapatybei nustatyti programose."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Įrenginio apsaugos funkcijos neveiks be ekrano užrakto.<xliff:g id="EMPTY_LINE">

</xliff:g>Įrenginyje išsaugotas kontrolinio kodo modelis ištrinamas. Be to, jūsų veido modelis bus visam laikui saugiai ištrintas. Negalėsite naudoti veido ar kontrolinio kodo tapatybei nustatyti programose."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Ištrinti"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ rekomenduoja naudoti patikimą PIN kodą arba slaptažodį, o jo neturint gali neveikti, kaip numatyta"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ rekomenduoja naudoti naują PIN kodą arba slaptažodį, jo neturint gali neveikti, kaip numatyta"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ rekomenduoja naudoti naują atrakinimo piešinį, PIN kodą arba slaptažodį, o jo neturint gali neveikti, kaip numatyta"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ rekomenduoja naudoti naują ekrano užraktą"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Bandykite dar kartą. <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> band. iš <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Duomenys bus ištrinti"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Jei kitu bandymu nupiešite netinkamą atrakinimo piešinį, šio įrenginio duomenys bus ištrinti"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Jei kitu bandymu įvesite netinkamą PIN kodą, šio įrenginio duomenys bus ištrinti"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Jei kitu bandymu įvesite netinkamą slaptažodį, šio įrenginio duomenys bus ištrinti"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Jei kitu bandymu nupiešite netinkamą atrakinimo piešinį, šis naudotojas bus ištrintas"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Jei kitu bandymu įvesite netinkamą PIN kodą, šis naudotojas bus ištrintas"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Jei kitu bandymu įvesite netinkamą slaptažodį, šis naudotojas bus ištrintas"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Jei kitu bandymu nupiešite netinkamą atrakinimo piešinį, darbo profilis ir jo duomenys bus ištrinti"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Jei kitu bandymu įvesite netinkamą PIN kodą, darbo profilis ir jo duomenys bus ištrinti"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Jei kitu bandymu įvesite netinkamą slaptažodį, darbo profilis ir jo duomenys bus ištrinti"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Turi būti bent # simbolis}one{Turi būti bent # simbolis}few{Turi būti bent # simboliai}many{Turi būti bent # simbolio}other{Turi būti bent # simbolių}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Jei naudojate tik skaičius, turi būti bent 1 skaitmuo}one{Jei naudojate tik skaičius, turi būti bent # skaitmuo}few{Jei naudojate tik skaičius, turi būti bent # skaitmenys}many{Jei naudojate tik skaičius, turi būti bent # skaitmens}other{Jei naudojate tik skaičius, turi būti bent # skaitmenų}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{PIN kode turi būti bent # skaitmuo}one{PIN kode turi būti bent # skaitmuo}few{PIN kode turi būti bent # skaitmenys}many{PIN kode turi būti bent # skaitmens}other{PIN kode turi būti bent # skaitmenų}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{PIN kodą turi sudaryti bent # skaitmuo, bet siekiant užtikrinti geresnę apsaugą rekomenduojama naudoti {minAutoConfirmLen} skaitmenų PIN kodą}one{PIN kodą turi sudaryti bent # skaitmuo, bet siekiant užtikrinti geresnę apsaugą rekomenduojama naudoti {minAutoConfirmLen} skaitmenų PIN kodą}few{PIN kodą turi sudaryti bent # skaitmenys, bet siekiant užtikrinti geresnę apsaugą rekomenduojama naudoti {minAutoConfirmLen} skaitmenų PIN kodą}many{PIN kodą turi sudaryti bent # skaitmens, bet siekiant užtikrinti geresnę apsaugą rekomenduojama naudoti {minAutoConfirmLen} skaitmenų PIN kodą}other{PIN kodą turi sudaryti bent # skaitmenų, bet siekiant užtikrinti geresnę apsaugą rekomenduojama naudoti {minAutoConfirmLen} skaitmenų PIN kodą}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Turi būti mažiau nei # simbolis}one{Turi būti mažiau nei # simbolis}few{Turi būti mažiau nei # simboliai}many{Turi būti mažiau nei # simbolio}other{Turi būti mažiau nei # simbolių}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Turi būti mažiau nei # skaitmuo}one{Turi būti mažiau nei # skaitmuo}few{Turi būti mažiau nei # skaitmenys}many{Turi būti mažiau nei # skaitmens}other{Turi būti mažiau nei # skaitmenų}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Įrenginio administratorius neleidžia naudoti pastarojo PIN kodo"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Negali būti netinkamų simbolių"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Turi būti bent viena raidė}one{Turi būti bent # raidė}few{Turi būti bent # raidės}many{Turi būti bent # raidės}other{Turi būti bent # raidžių}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Turi būti bent viena mažoji raidė}one{Turi būti bent # mažoji raidė}few{Turi būti bent # mažosios raidės}many{Turi būti bent # mažosios raidės}other{Turi būti bent # mažųjų raidžių}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Turi būti bent viena didžioji raidė}one{Turi būti bent # didžioji raidė}few{Turi būti bent # didžiosios raidės}many{Turi būti bent # didžiosios raidės}other{Turi būti bent # didžiųjų raidžių}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Turi būti bent vienas skaitmuo}one{Turi būti bent # skaitmuo}few{Turi būti bent # skaitmenys}many{Turi būti bent # skaitmens}other{Turi būti bent # skaitmenų}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Turi būti bent vienas specialusis simbolis}one{Turi būti bent # specialusis simbolis}few{Turi būti bent # specialieji simboliai}many{Turi būti bent # specialiojo simbolio}other{Turi būti bent # specialiųjų simbolių}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Turi būti bent vienas neraidinis simbolis}one{Turi būti bent # neraidinis simbolis}few{Turi būti bent # neraidiniai simboliai}many{Turi būti bent # neraidinio simbolio}other{Turi būti bent # neraidinių simbolių}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Turi būti bent vienas neskaitinis simbolis}one{Turi būti bent # neskaitinis simbolis}few{Turi būti bent # neskaitiniai simboliai}many{Turi būti bent # neskaitinio simbolio}other{Turi būti bent # neskaitinių simbolių}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Įrenginio administratorius neleidžia naudoti pastarojo slaptažodžio"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Didėjanti, mažėjanti ar pasikartojanti skaitmenų seka neleidžiama"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Patvirtinti"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Išvalyti"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Ekrano užraktas jau pakeistas. Bandykite dar kartą naudodami naują ekrano užraktą."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Atšaukti"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Kitas"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Įrenginio admin. progr."</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Nėra jokių aktyvių programų"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aktyvi programa}one{# aktyvi programa}few{# aktyvios programos}many{# aktyvios programos}other{# aktyvių programų}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Patikimos priemonės"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Jei norite naudoti, pirmiausia nustatykite ekrano užraktą"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Nėra"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{Viena aktyvi patikima priemonė}one{# aktyvi patikima priemonė}few{# aktyvios patikimos priemonės}many{# aktyvios patikimos priemonės}other{# aktyvių patikimų priemonių}}"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Susieti su „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="3047893658902159692">"Patvirtinkite, kad pridėtumėte antrą garso įrenginio dalį"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"„Bluetooth“ susiejimo kodas"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Įveskite susiejimo kodą, tada paspauskite „Return“ arba „Enter“"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN kodą sudaro raidės arba simboliai"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Paprastai 0000 arba 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Turi būti 16 skaitmenų"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Galbūt reikės šį PIN kodą įvesti kitame įrenginyje."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Galbūt reikės šį prieigos raktą įvesti kitame įrenginyje."</string>
    <string name="bluetooth_paring_group_msg" msgid="2455293929036668131">"Patvirtinkite, kad susietumėte su garso įrenginiu"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Leisti pasiekti jūsų kontaktus ir skambučių istoriją"</string>
    <string name="bluetooth_pairing_phonebook_toggle_text" msgid="2474015367387690034">"Taip pat leiskite pasiekti kontaktus ir skambučių istoriją"</string>
    <string name="bluetooth_pairing_phonebook_toggle_details" msgid="1367197978487212581">"Informacija bus naudojama skambučių pranešimams ir kt."</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Nepavyko prisijungti prie „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Pasiekiami įrenginiai"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Prijungti"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Atjungti"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Susieti ir jungti"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="7326727272747345476">"Kai „Bluetooth“ įj., įreng. gali užm. ryšį su kitais netoliese esančiais „Bluetooth“ įreng."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Kai „Bluetooth“ įjungtas, įrenginys gali užmegzti ryšį su kitais netoliese esančiais „Bluetooth“ įrenginiais.\n\nKad pagerintų įrenginio funkcijas, programos ir paslaugos vis tiek gali bet kada nuskaityti ieškodamos netoliese esančių įrenginių, net kai „Bluetooth“ išjungtas. Tai galima naudoti norint, pvz., tobulinti pagal vietovę teikiamas funkcijas ir paslaugas. Tai galite pakeisti „Bluetooth“ nuskaitymo nustatymuose."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Keisti"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Išsami įrenginio info."</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Klaviatūros nustatymai"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Įrenginio „Bluetooth“ adresas: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Įrenginio „Bluetooth“ adresas:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Pamiršti įrenginį?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Pašalinti susiejimą"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Atjungti programą?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Programa „<xliff:g id="APP_NAME">%1$s</xliff:g>“ nebeprisijungs prie „<xliff:g id="DEVICE_NAME">%2$s</xliff:g>“"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Eksperiment. funkc. Gerina garso kokybę."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Pamiršti įrenginį"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Atjungti programą"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maksimalus prijungtų „Bluetooth“ garso įrenginių skaičius"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Pasirinkite maksimalų prijungtų „Bluetooth“ garso įrenginių skaičių"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"NFC dėklo derinimo žurnalas"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Padidinti NFC dėklo įrašymo į žurnalą lygį"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"NFC daugiažodžių paslaugų teikėjo derinimo žurnalas"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Į pranešimus apie riktus įtraukiami papildomi konkretaus įrenginio paslaugų teikėjo žurnalai, kuriuose gali būti privačios informacijos."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"NFC NCI nefiltruotas žurnalas"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Užfiksuojami išsamūs NFC paketai, kuriuose gali būti privačios informacijos."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Paleisti įrenginį iš naujo?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Išsamių NFC duomenų įrašymas gali būti naudojamas tik kuriant produktą. Į pranešimus apie riktus įtraukiama papildomų NFC duomenų, kuriuose gali būti privačios informacijos. Jei norite pakeisti šį nustatymą, paleiskite įrenginį iš naujo."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Paleisti iš naujo"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Perdavimas"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"ekrano vaizdo bendrinimas"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Įgalinti belaidį rodymą"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Nerasta netoliese esančių įrenginių."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Jungiama"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Prijungta"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"Naudojama"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Nepasiekiamas"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Belaidžio rodymo parinktys"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Pamiršti"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Atlikta"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Pavadinimas"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"6 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Prisijungti"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Atidaryti svetainę"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Liko <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Baigs galioti <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"Programa „<xliff:g id="REQUESTER">%s</xliff:g>“ nori įjungti „Wi-Fi“"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"Programa „<xliff:g id="REQUESTER">%s</xliff:g>“ nori išjungti „Wi-Fi“"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Patvirtinti derinamų pr. baitinę progr."</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Leisti ART patvirtinti derinamų programų baitinę programą"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Rodyti atnaujinimo dažnį"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Rodyti dabartinio vaizdo atnaujinimo dažnį"</string>
    <string name="show_hdr_sdr_ratio" msgid="4188007289024955585">"Rodyti HDR / SDR santykį"</string>
    <string name="show_hdr_sdr_ratio_summary" msgid="986292785096013733">"Rodyti dabartinį HDR / SDR santykį"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Norint naudoti NFC reikia panaikinti įrenginio operatoriaus pasirinkimo ribojimą"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Parengta perduoti programos turinį naudojant ALR"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Išjungta"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Negalima, nes išjungtas NFC"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Kai ši funkcija įjungta, galite programos turinį perduoti į kitą ALR palaikantį įrenginį laikydami du įrenginius šalia. Pavyzdžiui, galite perduoti tinklalapius, „YouTube“ vaizdo įrašus, kontaktus ir dar daugiau.\n\nTiesiog sudėkite du įrenginius vieną šalia kito (įprastai suglaudę galinėmis dalimis) ir palieskite ekraną. Programa nustato, kas bus perduodama."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi-Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Naudoti „Wi-Fi“"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"„Wi-Fi“ nustatymai"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Pasirinkti „Wi-Fi“"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"„Wi-Fi“ įjungiama…"</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"„Wi-Fi“ išjungiama…"</string>
    <string name="wifi_error" msgid="4903954145386086899">"Klaida"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"5 GHz juosta neprieinama šioje šalyje"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"Veikia lėktuvo režimu"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Pranešti apie viešuosius tinklus"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Pranešti, kai pasiekiamas aukštos kokybės viešas tinklas"</string>
    <string name="wifi_allow_wep_networks" msgid="8772342993235292010">"Leisti WEP tinklus"</string>
    <string name="wifi_allow_wep_networks_summary" msgid="3033397893296724615">"WEP yra senesnis ir mažiau saugus saugos protokolas"</string>
    <string name="wifi_allow_wep_networks_summary_carrier_not_allow" msgid="6298103289728210026">"Jūsų operatorius neleidžia WEP tinklų, nes jie mažiau saugūs"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Automatiškai įjungti „Wi‑Fi“"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"„Wi‑Fi“ bus vėl įjungtas esant šalia išsaugotų aukštos kokybės tinklų, pvz., jūsų namų tinklo"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Nepasiekiama, nes vietovės parinktis išjungta. Įjunkite "<annotation id="link">"vietovę"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Įdiegti sertifikatus"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Kad pagerintų vietos nustatymo tikslumą, programos ir paslaugos vis tiek bet kada gali nuskaityti „Wi‑Fi“ tinklus, net jei „Wi‑Fi“ išjungtas. Tai gali būti naudojama siekiant pagerinti pagal vietovę teikiamas funkcijas ir paslaugas. Tai galite pakeisti <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>„Wi-Fi“ nuskaitymo nustatymuose<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Kad būtų galima patobulinti vietovės informacijos tikslumą, įjunkite „Wi-Fi“ nuskaitymą <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>„Wi-Fi“ nuskaitymo nustatymuose<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Automatiškai perjungti į mobiliojo ryšio duomenis"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Naudoti mobiliojo ryšio duomenis, kai „Wi-Fi“ tinkle nėra interneto ryšio. Galite būti apmokestinti už naudojamus duomenis."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Pridėti tinklą"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"„Wi‑Fi“ nuostatos"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"„Wi‑Fi“ automatiškai įjungiamas iš naujo"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"„Wi‑Fi“ automatiškai neįjungiamas iš naujo"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Tiesiog. „Wi-Fi“ r."</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Kad peržiūrėt. galimus tinklus, įjunkite „Wi-Fi“."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Ieškoma tinklų…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Neturite leidimo keisti „Wi‑Fi“ tinklą."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Įjungti „Wi‑Fi“ nuskaitymą?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Norėdami įjungti „Wi‑Fi“ automatiškai pirmiausia turite įjungti „Wi‑Fi“ nuskaitymą."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"„Wi-Fi“ nuskaitymo funkcija leidžia programoms ir paslaugoms bet kuriuo metu nuskaityti ieškant „Wi‑Fi“ tinklų, net kai „Wi‑Fi“ išjungtas. Tai galima naudoti norint, pvz., tobulinti pagal vietovę teikiamas funkcijas ir paslaugas."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Įjungti"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"„Wi‑Fi“ nuskaitymas įjungtas"</string>
    <string name="wifi_settings_warning_wep_network" msgid="2655077013800385646">"Šiame tinkle naudojamas senesnis ir mažiau saugus saugos protokolas"</string>
    <string name="wifi_settings_wep_networks_blocked_title" msgid="8337700496544833669">"Tinklas „<xliff:g id="NAME">%1$s</xliff:g>“ užblokuotas"</string>
    <string name="wifi_settings_wep_networks_summary_toggle_off" msgid="1113138364046142949">"Šiame tinkle naudojamas senesnis ir mažiau saugus saugos protokolas, vadinamas WEP. Jei vis tiek norite prisijungti, galit leisti WEP tinklus."</string>
    <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Jūsų operatorius neleidžia prisijungti prie šio tinklo, nes jame naudojamas senesnis ir mažiau saugus saugos protokolas"</string>
    <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Leisti WEP"</string>
    <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Uždaryti"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Išplėstinės parinktys"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Išskleidžiamojo sąrašo išplėstinės parinktys"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"išskleisti"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Tinklo pavadinimas"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Įveskite SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Sauga"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Paslėptas tinklas"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Jei maršruto parinktuvas netransliuoja tinklo ID, bet vėliau norėsite prie jo prisijungti, galite nustatyti tinklą kaip paslėptą.\n\nGali kilti saugos pavojus, nes telefonas reguliariai transliuos signalą, kad surastų tinklą.\n\nNustačius tinklą kaip paslėptą, maršruto parinktuvo nustatymai nebus pakeisti."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Signalo stiprumas"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Būsena"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Perdavimo nuorodos sparta"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Gavimo nuorodos sparta"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Susiejimo greitis"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Dažnis"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP adresas"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Išsaugota per"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"„<xliff:g id="NAME">%1$s</xliff:g>“ prisijungimo duomenys"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP būdas"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"2 tapatybės nustatymo fazė"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA sertifikatas"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Minimali TLS versija"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Internetinio sertifikato būsena"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domenas"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Naudotojo sertifikatas"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Tapatybė"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anoniminė tapatybė"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Slaptažodis"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Rodyti slaptažodį"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"2,4 GHz dažnio juosta"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Pageidaujama 5,0 GHz dažnio juosta"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP nustatymai"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privatumas"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Prenumerata"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Prenumeratos peržiūra arba keitimas"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Atsitikt. tv. pasir. MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Įrenginio pridėjimas"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Nustatykite QR kodą centre, kad galėtumėte pridėti įrenginį prie „<xliff:g id="SSID">%1$s</xliff:g>“"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"QR kodo nuskaitymas"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Centruokite toliau pateiktą QR kodą, kad galėtumėte prisijungti prie „<xliff:g id="SSID">%1$s</xliff:g>“"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Prisijunkite prie „Wi‑Fi“ nuskaitydami QR kodą"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"„Wi‑Fi“ bendrinimas"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Nuskaitykite šį QR kodą kitu įrenginiu, kad prisijungtumėte prie „<xliff:g id="SSID">%1$s</xliff:g>“"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Nuskaitykite šį QR kodą, kad prisijungtumėte prie „<xliff:g id="SSID">%1$s</xliff:g>“"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Bandykite dar kartą. Jei problema išlieka, susisiekite su įrenginio gamintoju"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Iškilo problema"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Įsitikinkite, kad įrenginys įjungtas į maitinimo lizdą, įkrautas ir įjungtas jo maitinimas"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Įsitikinkite, kad įrenginys įjungtas į maitinimo lizdą, įkrautas ir įjungtas jo maitinimas. Jei problema išlieka, susisiekite su įrenginio gamintoju"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Šiame įrenginyje nepalaikomas „<xliff:g id="SSID">%1$s</xliff:g>“ pridėjimas"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Pabandykite perkelti įrenginį arčiau prie „Wi‑Fi“ prieigos taško ar maršruto parinktuvo"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Patikrinkite slaptažodį ir bandykite dar kartą"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Susisiekite su įrenginio gamintoju"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Patikrinkite ryšį ir bandykite dar kartą"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Tinklo pasirinkimas"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Kad prijungtumėte įrenginį, pasirinkite tinklą"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Pridėti šį įrenginį prie „<xliff:g id="SSID">%1$s</xliff:g>“?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"„Wi‑Fi“ bendrinamas su įrenginu"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Pridėti kitą įrenginį"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Pasirinkti kitą tinklą"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Nepavyko pridėti įrenginio"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Rastas įrenginys"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Bendrinamas „Wi‑Fi“ su šiuo įrenginiu…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Prisijungiama…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Viešosios interneto prieigos taško bendrinimas"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Savo tapatybės patvirtinimas"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"„Wi-Fi“ slaptažodis: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Viešosios interneto prieigos taško slaptažodis: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automatiškai prisijungti"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Leisti prisijungti prie šio tinklo, kai įrenginys bus tinklo diapazone"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Pridėti įrenginį"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Naudokite QR kodą, kad galėtumėte pridėti įrenginį prie šio tinklo"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR kodas netinkamo formato"</string>
    <string name="retry" msgid="7542103800274026915">"Bandyti dar kartą"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Bendrinti su kitais įrenginio naudotojais"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(nepakeista)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Pasirinkite"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Pridėti keli sertifikatai)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Naudoti sistemos sertifikatus"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Neteikti"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Pasitikėti naudojant pirmą kartą"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Tinklo pavadinimas per ilgas."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Būtina nurodyti domeną."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Būtinas sertifikatas."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"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_turn_on_message_unknown" msgid="4903345360745717385">"Kad tiksliau nustatytų vietą ir dėl kitų priežasčių nežinoma programa prašo leidimo nuskaityti tinklus net kai „Wi-Fi“ išjungtas.\n\nAr norite suteikti leidimą nuskaityti visoms to prašančioms programoms?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Leisti"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Atmesti"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Šiame tinkle nėra interneto ryšio. Likti prisijungus?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Kai kurios programos ir paslaugos gali neveikti dėl riboto ryšio. Vis tiek naudoti?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Daugiau neklausti šiame tinkle"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"„Wi‑Fi“ tinkle nėra interneto ryšio"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Galite perjungti į mobiliojo ryšio tinklą, kai „Wi-Fi“ ryšys silpnas. Gali būti taikomas duomenų naudojimo mokestis."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Perjungti į mobiliojo ryšio tinklą"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Toliau naudoti „Wi‑Fi“"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Daugiau niekada neberodyti"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Prijungti"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Prisijungta prie „<xliff:g id="NETWORK_NAME">%1$s</xliff:g>“"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Prijungiama…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Jungiantis prie tinklo įvyko klaida."</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Tinklas ne diapazone"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Pamiršti"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Keisti"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Išsaugoti"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Išsaugant tinklą įvyko klaida."</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Atšaukti"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Pamiršti tinklą?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{Vienas tinklas}one{# tinklas}few{# tinklai}many{# tinklo}other{# tinklų}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{Viena prenumerata}one{# prenumerata}few{# prenumeratos}many{# prenumeratos}other{# prenumeratų}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{Vienas tinklas ir prenumerata}one{# tinklas ir prenumerata}few{# tinklai ir prenumeratos}many{# tinklo ir prenumeratos}other{# tinklų ir prenumeratų}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Įrenginio MAC adresas"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Atsitiktinis MAC adresas"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Atsitiktinai parinktas MAC adresas (pastarasis)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Išsami tinklo info."</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Potinklio kaukė"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Tipas"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"„IPv6“ adresai"</string>
    <string name="hotspot_device_details_category" msgid="3110651914598697220">"Išsami viešosios interneto prieigos taško įrenginio informacija"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Interneto šaltinis"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"Wi-Fi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Mobiliojo ryšio duomenys"</string>
    <string name="internet_source_ethernet" msgid="8338472576454100966">"Eternetas"</string>
    <string name="hotspot_battery_charging_summary" msgid="6690892148553288457">"<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> – įkraunama"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Viešosios interneto prieigos taško ryšys"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Ryšio stiprumas"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Išsaugoti tinklai"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Prenumeratos"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Kiti tinklai"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Įveskite galiojantį IP adresą."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Įveskite galiojantį tinklų sietuvo adresą."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Įveskite galiojantį DNS adresą."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Įveskite 0–32 simbolių tinklo kodą."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (nebent nepaisoma taikant privačią DNS)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (nebent nepaisoma taikant privačią DNS)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Tinklų sietuvas"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Tinklo kodo ilgis"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Tiesiog. „Wi-Fi“ r."</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Ieškoti įrenginių"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Ieškoma…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Pervardyti įrenginį"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Lygiaverčiai įrenginiai"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Įsimintos grupės"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Nepavyko prijungti."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Nepavyko pervardyti įrenginio."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Atsijungti?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Atsijungus, bus nutrauktas ryšys su „<xliff:g id="PEER_NAME">%1$s</xliff:g>“."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"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="8476985132989357041">"Atšaukti kvietimą?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"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="4880242270742385699">"Pamiršti šią grupę?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"„Wi-Fi“ vieš. int. pr. taš."</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Internetas ar turinys nebendrinamas su kitais įrenginiais"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Nenustatyta jokių slaptažodžių"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Viešosios interneto prieigos taško pavadinimas"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Viešosios interneto prieigos taško slaptažodis"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Išjungti viešosios interneto prieigos tašką automatiškai"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Kai nėra susietų įrenginių"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Praplėsti suderinamumą"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Padeda kitiems įrenginiams rasti šį viešosios interneto prieigos tašką. Sumažinama viešosios interneto prieigos taško sparta."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Padeda kitiems įrenginiams rasti šį viešosios interneto prieigos tašką. Naudojama daugiau akumuliatoriaus energijos."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Sparta ir suderinamumas"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2,4 GHz / suderinama su dauguma įrenginių"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz / suderinama su daug įrenginių"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz / suderinama su keliais įrenginiais"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2,4 ir 5 GHz / suderinama su dauguma įrenginių"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Pasirinkite viešosios interneto prieigos taško dažnį. Dažnis turi įtakos prisijungimo greičiui ir kokie įrenginiai gali aptikti viešosios interneto prieigos tašką."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Pageidaujamas dažnis"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Mažesnis greitis. Suderinama su dauguma įrenginių."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Didelis greitis. Suderinama su daug įrenginių."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 ir 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Didelis greitis. Šis dviejų dažnio juostų viešosios interneto prieigos taškas suderinamas su dauguma įrenginių."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Didžiausias greitis. Suderinama su keliais įrenginiais."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Nepasiekiama jūsų šalyje ar regione"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Jei pageidaujamas dažnis nepasiekiamas, viešosios interneto prieigos taškas gali naudoti kitą dažnį. Pakeitus dažnį gali pasikeisti viešosios interneto prieigos taško saugos nustatymai."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Nepasiekiama su 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Saugos nustatymai gali pasikeisti, jei pakeisite viešosios interneto prieigos taško dažnį"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Spartusis viešosios interneto prieigos taškas"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"Įjungta"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Išjungta"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Įjungiamas viešosios interneto prieigos taškas…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Išjungiamas viešosios interneto prieigos taškas…"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Įrenginio kaip modemo naudojimas nepasiekiamas"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Jei reikia išsamios informacijos, susisiekite su operatoriumi"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> aktyvus"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"„AndroidHotspot“"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Išsaugoti šį tinklą?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Išsaugoma…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Išsaugota"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Negalima išsaugoti. Bandykite dar kartą."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Išsaugoti tinklus?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Išsaugoma tinklų: <xliff:g id="NUMBER">%d</xliff:g>…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Tinklai išsaugoti"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"„Wi-Fi“ skambinimas"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Išplėskite skamb. aprėptį naudodami „Wi‑Fi“"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Įjunkite „Wi‑Fi“ skambinimą, kad išplėstumėte aprėptį"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Skambinimo nuostata"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Skambinimo nuostata"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Tarptinklinio ryšio nuostata"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Tarptinklinio ryšio nuostata"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"„Wi-Fi“ ryšys"</item>
    <item msgid="8622872038388687383">"Mobiliojo ryšio tinklas"</item>
    <item msgid="3027927219952052398">"Tik „Wi-Fi“ ryšys"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"„Wi-Fi“ ryšys"</item>
    <item msgid="7566603075659706590">"Mobiliojo ryšio tinklas"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Jei „Wi‑Fi“ nepasiekiamas, naudokite mobiliojo ryšio tinklą"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Jei mobiliojo ryšio tinklas nepasiekiamas, naudoti „Wi‑Fi“"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Skambinimas naudojant „Wi-Fi“. Nutrūkus „Wi‑Fi“ skambutis bus baigtas."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Kai „Wi-Fi“ skambinimas įjungtas, telefonas gali nukreipti skambučius per „Wi-Fi“ tinklus arba operatoriaus tinklą, atsižvelgiant į jūsų nuostatas ir stipresnį signalą. Prieš įjungdami šią funkciją, pasikonsultuokite su operatoriumi dėl mokesčių ir kitos išsamios informacijos.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="8102786488994263815">"Adresas kritiniu atveju"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Naudojama kaip vietos informacija, kai skambinate pagalbos numeriu naudodami „Wi-Fi“"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Sužinokite daugiau"</annotation>" apie privataus DNS funkcijas"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Įjungta"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Suaktyvinti „Wi-Fi“ skambinimo funkciją"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Įjungti „Wi-Fi“ skambinimo funkciją"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Atsijungta nuo „<xliff:g id="SSID">%1$s</xliff:g>“"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Garsas ir vibravimas"</string>
    <string name="account_settings" msgid="255404935489127404">"Paskyros"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Darbo profilio paskyros – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Asmeninio profilio paskyros"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Identiškos profilio kopijos paskyros"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Darbo paskyra – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Asmeninė paskyra – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Ieškoti"</string>
    <string name="display_settings" msgid="7197750639709493852">"Ekranas"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Automatiškai sukti ekraną"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Išjungta"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Įjungta"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Įjungta – pagal veidą"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Veido aptikimas"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Sužinokite daugiau apie automatinį pasukimą"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Ekrano skyra"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Didelė skyra"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Visa skyra"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Esant visai skyrai eikvojama daugiau akumuliatoriaus energijos. Perjungus skyrą, kai kurios programos gali būti paleistos iš naujo."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Pasirinkta"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Spalvos"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Natūrali"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Suintensyvinta"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Sodri"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Prisitaikanti"</string>
    <string name="brightness" msgid="6216871641021779698">"Šviesumo lygis"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Prisitaikantis šviesumas"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Ekrano šviesumas automatiškai prisitaikys prie jūsų aplinkos ir veiklos. Galite šliaužiklį perkelti patys, kad prisitaikantis šviesumas įsimintų jūsų nuostatas."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Įjungta"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Išjungta"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Pateikti baltos spalv. balansą"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Toliau naudoti programas, kai įrenginys sulenktas"</string>
    <string name="disable_game_default_frame_rate_title" msgid="3712908601744143753">"Išjungti numatytąjį žaidimų kadrų dažnį"</string>
    <string name="disable_game_default_frame_rate_summary" msgid="4436762704707434225">"Išjungti maksimalaus <xliff:g id="FRAME_RATE">%1$d</xliff:g> Hz žaidimų kadrų dažnio ribojimą."</string>
    <string name="peak_refresh_rate_title" msgid="2056355754210341011">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="3212309985294885790">"Automatiškai padidinamas kai kurio turinio atnaujinimo dažnis iki <xliff:g id="ID_1">%1$d</xliff:g> Hz. Vartojama daugiau akumuliatoriaus energijos."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Priverstinai nustatyti didžiausią atnaujinimo dažnį"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Didžiausias atnaujinimo dažnis, siekiant patobulinti palietimo atsakomumą ir animacijos kokybę. Vartojama daugiau akumuliatoriaus energijos."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Žiūrėjimas į ekraną"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Reikalinga prieiga prie fotoaparato"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Fotoaparato prieiga reikalinga žiūrėjimo į ekraną funkcijai. Palieskite ir tvarkykite įrenginio suasmeninimo paslaugų leidimus"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Tvarkyti leidimus"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Neleidžiama išsijungti ekranui, kol į jį žiūrite"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Funkcija „Žiūrėjimas į ekraną“ naudoja priekinį fotoaparatą, kad nustatytų, ar kas nors žiūri į ekraną. Ši funkcija veikia pačiame įrenginyje, jokie vaizdai neišsaugomi ir nesiunčiami „Google“."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Žiūrėjimo į ekraną funkcijos įjungimas"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Ekranas neišsijungs, kol į jį žiūrėsite"</string>
    <string name="power_consumption_footer_summary" msgid="4901490700555257237">"Dėl ilgesnio ekrano skirtojo laiko bus eikvojama daugiau akumuliatoriaus energijos."</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Fotoaparatas užrakintas"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Fotoaparatas turi būti atrakintas, kad būtų galima naudoti veido aptikimo funkciją"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Fotoaparatas turi būti atrakintas, kad būtų galima naudoti žiūrėjimo į ekraną funkciją"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Veido aptikimo funkcijai reikalinga prieiga prie fotoaparato. Palieskite ir tvarkykite įrenginio suasmeninimo paslaugų leidimus"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Tvarkyti leidimus"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Nakties šviesa"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Nustačius Nakties šviesą, naktį rodomas gintaro atspalvio ekranas. Taip bus patogiau žiūrėti į ekraną prietemoje ir galbūt lengviau užmigsite."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Tvarkaraštis"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Nėra"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Įjungiama pasirinktu laiku"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Įjungta nuo saulėl. iki saulėt."</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Pradžios laikas"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Pabaigos laikas"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensyvumas"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Niekada nebus įjungta automatiškai"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Bus įjungta automatiškai <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Bus įjungta automatiškai saulei leidžiantis"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Niekada nebus išjungta automatiškai"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Bus išjungta automatiškai <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Bus išjungta automatiškai saulei tekant"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Nakties šviesa šiuo metu neįj."</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Reikia įrenginio vietovės, kad būtų galima nustatyti laiką nuo saulėlydžio iki saulėtekio."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Vietovės nustatymai"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Įjungti dabar"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Išjungti dabar"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Įjungti iki saulėtekio"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Išjungti iki saulėlydžio"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Tamsus režimas"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Tvarkaraštis"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Nėra"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Įjungta nuo saulėl. iki saulėt."</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Įjungiama pasirinktu laiku"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Įjungiama atėjus laikui miegoti"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Būsena"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Niekada nebus įjungta automatiškai"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Bus įjungta automatiškai saulei leidžiantis"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Bus įjungta automatiškai <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Bus įjungta automatiškai atėjus laikui miegoti"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Niekada nebus išjungta automatiškai"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Bus išjungta automatiškai saulei tekant"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Bus išjungta automatiškai <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Bus išjungta automatiškai pasibaigus laikui miegoti"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tamsiojoje temoje naudojamas tamsus fonas, kad akumuliatorius ilgiau veiktų tam tikruose ekranuose. Tamsiosios temos tvarkaraščiai neprasideda, kol ekranas neišsijungia."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Tamsioji tema šiuo metu veikia pagal miego režimo tvarkaraštį"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Miego režimo nustatymai"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Ekrano skirtasis laikas"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Po <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neveiklumo"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Nenustatyta"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Darbalaukio fonas"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Ekrano fonas ir stilius"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Pagrindinis, užrakinimo ekranas"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Pakeiskite ekrano foną"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Suasmeninkite ekraną"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Pasirinkti darbalaukio foną iš"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Telefono tinkinimas"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Išbandykite skirtingus stilius, ekrano fonus ir kt."</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Ekrano užsklanda"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"ekrano užsklanda"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Nepasiekiama dėl įjungto laiko eiti miegoti režimo"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Ekrano užsklandos naudojimas"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Įkraunat ar prijungus prie doko"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Kai prijungta prie doko ir kraunama"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Įkraunant"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Kai yra doke"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Niekada"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Įjungta / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Išjungta"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Kada paleisti"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Pakelti ir pažadinti"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Adaptyvusis vaizdas"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kada rodyti"</string>
    <string name="doze_title" msgid="1523090408230862316">"Ekrano pažad. gavus pranešimą"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Tamsus ekranas įjungiamas gavus naujų pranešimų"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Visada rodyti laiką ir inform."</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Naudojama daugiau akumuliatoriaus energijos"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Pusjuodis tekstas"</string>
    <string name="title_font_size" msgid="570613010306330622">"Šrifto dydis"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Teksto padidinimas arba sumažinimas"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"SIM kortelės užrakto nustatymai"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"SIM kortelės užraktas"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Užrakinti SIM kortelę"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Pakeisti SIM kortelės PIN kodą"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"SIM kortelės PIN kodas"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Užrakinti SIM kortelę"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Atrakinti SIM kortelę"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Senas SIM kortelės PIN kodas"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Naujas SIM kortelės PIN kodas"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Dar kartą įveskite naują PIN kodą"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"SIM kortelės PIN kodas"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Įveskite PIN kodą, sudarytą iš 4–8 sk."</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PIN kodai neatitinka"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"SIM kortelės PIN kodas sėkmingai pakeistas"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Nepavyksta išjungti PIN kodo."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Nepavyksta įjungti PIN kodo."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"Gerai"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Atšaukti"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Naudoti „<xliff:g id="CARRIER">%1$s</xliff:g>“ mob. ryšio duomen.?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Naudojate „<xliff:g id="CARRIER2_0">%2$s</xliff:g>“ mobiliojo ryšio duomenims. Jei perjungsite į „<xliff:g id="CARRIER1">%1$s</xliff:g>“, „<xliff:g id="CARRIER2_1">%2$s</xliff:g>“ paslaugos nebebus naudojamos mobiliojo ryšio duomenims."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Naudoti „<xliff:g id="CARRIER">%1$s</xliff:g>“"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Atnaujinti pageid. SIM kort.?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"„<xliff:g id="NEW_SIM">%1$s</xliff:g>“ yra vienintelė SIM kortelė įrenginyje. Ar norite naudoti šią SIM kortelę mobiliojo ryšio duomenims, skambučiams ir SMS pranešimams?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Tobulinti mob. ryšio aprėptį?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Leiskite įrenginyje automatiškai perjungti į „<xliff:g id="BACKUP_CARRIER">%1$s</xliff:g>“ mobiliojo ryšio duomenis, kai jų pasiekiamumas geresnis."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Skambučiai, pranešimai ir tinklo srautas gali būti rodomi jūsų organizacijai."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Netinkamas SIM kortelės PIN kodas. Reikės susisiekti su operatoriumi, kad atrakintų įrenginį."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Netinkamas SIM kortelės PIN kodas. Jums liko # bandymas. Paskui reikės susisiekti su operatoriumi, kad atrakintumėte įrenginį.}one{Netinkamas SIM kortelės PIN kodas. Jums liko # bandymas.}few{Netinkamas SIM kortelės PIN kodas. Jums liko # bandymai.}many{Netinkamas SIM kortelės PIN kodas. Jums liko # bandymo.}other{Netinkamas SIM kortelės PIN kodas. Jums liko # bandymų.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Netinkamas SIM kortelės PIN kodas. Jums liko vienas bandymas, paskui reikės susisiekti su operatoriumi, kad atrakintų įrenginį."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Nepavyko atlikti SIM kortelės PIN kodo operacijos."</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Sistemos naujiniai"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"„Android“ versija"</string>
    <string name="security_patch" msgid="4071756145347865382">"„Android“ saugos naujinys"</string>
    <string name="model_info" msgid="8997566254717810904">"Modelis"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Aparatinės įrangos versija"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Gamybos metai"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"Įrangos ID"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Nemoduliuojamo perdavimo versija"</string>
    <string name="kernel_version" msgid="3513538109381366881">"„Kernel“ versija"</string>
    <string name="build_number" msgid="9009733242117579826">"Versijos numeris"</string>
    <string name="module_version" msgid="1787518340082046658">"„Google Play“ sistemos naujinys"</string>
    <string name="battery_info" msgid="7873528123969546728">"Akumuliatoriaus informacija"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Negalima"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Saugykla"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Saugykla ir talpykla"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Atmintinės nustatymai"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (SIM kortelės anga <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (<xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g> SIM lizdas)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (<xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g> SIM lizdas) (pagrindinis)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Norėdami peržiūrėti pasirinkite išsaugotą tinklą"</string>
    <string name="status_imei" msgid="5719752369250485007">"IMEI"</string>
    <string name="status_imei_sv" msgid="6908985558726440951">"IMEI SV"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN."</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"PRL versija"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (<xliff:g id="MEID_SLOT_ID">%1$d</xliff:g> SIM lizdas)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (<xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g> SIM lizdas) (pagrindinis)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Įjungta"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Išjungta"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Mobiliojo ryšio duomenų tinklo tipas"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Mobiliojo ryšio balso tinklo tipas"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Operatoriaus informacija"</string>
    <string name="status_data_state" msgid="525196229491743487">"Mobiliojo tinklo būsena"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Paslaugos būsena"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Signalo stiprumas"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Tarptinklinis ryšys"</string>
    <string name="status_operator" msgid="4335640583552058491">"Tinklas"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"„Wi-Fi“ MAC adresas"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Įrenginio „Wi‑Fi“ MAC adresas"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"„Bluetooth“ adresas"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Serijos numeris"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Veikimo laikas"</string>
    <string name="battery_manufacture_date" msgid="7139426520156833987">"Pagaminimo data"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Pirmo naudojimo data"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Ciklų skaičius"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Nepasiekiama"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Skaičiuojama..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Pervardyti"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Įdėti"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Pašalinti"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formatuoti SD kortelę kaip nešiojamąją saugyklą"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formatuoti kortelę"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Suformat. kaip neš. saugyklą"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formatuoti"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Perkelti duomenis"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Pamiršti"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Nustatyti"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Atlaisvinti vietos"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Tvarkyti saugyklą"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Atlaisvinti vietos"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Eikite į Failų programą, jei norite tvarkyti ir atlaisvinti vietos"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Kiti naudotojai"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_mount_success" msgid="393972242641313135">"<xliff:g id="NAME">%1$s</xliff:g> įdėta"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Nepavyko įdėti <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> saugiai pašalinta"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Nepavyko saugiai pašalinti <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Pervardyti atmintį"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Ši saugykla (<xliff:g id="NAME_0">^1</xliff:g>) sugadinta. \n\nKad galėtumėte naudoti <xliff:g id="NAME_1">^1</xliff:g>, pirmiausia turėsite atlikti sąranką."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Galite suformatuoti šią SD kortelę ir joje saugoti nuotraukas, vaizdo įrašus, muziką bei kitą turinį, kurį galėsite pasiekti kituose įrenginiuose. \n\n"<b>"Visi šioje SD kortelėje esantys duomenys bus ištrinti."</b>" \n\n"<b>"Prieš formatuojant"</b>" \n\n"<b>"Sukurkite atsarginę nuotraukų ir kitos medijos kopiją"</b>" \nPerkelkite medijos failus į kitą saugyklą šiame įrenginyje arba į kompiuterį per USB laidą. \n\n"<b>"Programų atsarginės kopijos"</b>" \nVisos programos, saugomos šioje „<xliff:g id="NAME">^1</xliff:g>“, bus pašalintos ir jų duomenys bus ištrinti. Norėdami pasilikti šias programas, perkelkite jas į kitą saugyklą šiame įrenginyje."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Kai pašalinsite šią <xliff:g id="NAME_0">^1</xliff:g>, joje saugomos programos nebeveiks, o joje saugomi medijos failai nebus pasiekiami, kol ją vėl įdėsite."</b>\n\n"Ši <xliff:g id="NAME_1">^1</xliff:g> suformatuota veikti tik šiame įrenginyje. Ji neveiks kituose įrenginiuose."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Kad galėtumėte naudoti programas, nuotraukas ar duomenis iš <xliff:g id="NAME">^1</xliff:g>, įdėkite ją iš naujo.\n\nArba galite pasirinkti pamiršti šią saugyklą, jei įrenginys nebepasiekiamas.\n\nJei pasirinksite pamiršti įrenginį, visi duomenis iš to įrenginio bus prarasti visam laikui.\n\nVėliau galėsite iš naujo įdiegti programas, bet jų duomenys, saugomi šiame įrenginyje, bus prarasti."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Pamiršti <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Visi šioje saugykloje (<xliff:g id="NAME">^1</xliff:g>) saugomi duomenys, programos ir nuotraukos bus prarasti visam laikui."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Sistema apima failus, naudojamus vykdant <xliff:g id="VERSION">%s</xliff:g> versijos „Android“"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Svečio režimu SD kortelių formatuoti negalima"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formatuojama <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Neatjunkite saugyklos (<xliff:g id="NAME">^1</xliff:g>), kol ji formatuojama."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"„<xliff:g id="NAME">^1</xliff:g>“ suformatuota"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Perkelti programą <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Programos <xliff:g id="APP">^1</xliff:g> ir jos duomenų perkėlimas į <xliff:g id="NAME_0">^2</xliff:g> truks neilgai. Negalėsite naudoti programos, kol perkėlimas bus baigtas. \n\nKol perkeliama, nepašalinkite <xliff:g id="NAME_1">^2</xliff:g>."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Jei norite perkelti duomenis, turite atrakinti naudotoją <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Perkeliama programa <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Nepašalinkite <xliff:g id="NAME">^1</xliff:g>, kol perkeliama. \n\nPrograma <xliff:g id="APP">^2</xliff:g> šiame įrenginyje nebus pasiekiama, kol perkėlimas bus baigtas."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Kaip naudosite šią saugyklą (<xliff:g id="NAME">^1</xliff:g>)?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Arba"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formatuoti SD kortelę kaip nešiojamąją saugyklą"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Saugokite nuotraukas, vaizdo įrašus, muziką ir kitą turinį, kurį galėsite pasiekti kituose įrenginiuose. &lt;a href=https://support.google.com/android/answer/12153449&gt;Sužinokite daugiau apie SD kortelės nustatymą&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formatuoti"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Nustatyti vėliau"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Formatuoti šią saugyklą (<xliff:g id="NAME">^1</xliff:g>)?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Reikia formatuoti „<xliff:g id="NAME_0">^1</xliff:g>“, kad galėtumėte saugoti programas, failus ir mediją. \n\nFormatuojant bus ištrintas „<xliff:g id="NAME_1">^2</xliff:g>“ esantis turinys. Kad neprarastumėte turinio, sukurkite atsarginę jo kopiją kitoje „<xliff:g id="NAME_2">^3</xliff:g>“ ar kitame įrenginyje."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Šią „<xliff:g id="NAME_0">^1</xliff:g>“ reikia formatuoti, kad būtų galima joje saugoti nuotraukas, vaizdo įrašus, muziką ir kitą turinį. \n\nFormatuojant bus ištrinamas „<xliff:g id="NAME_1">^2</xliff:g>“ esantis turinys. Kad neprarastumėte turinio, sukurkite atsarginę jo kopiją kitoje „<xliff:g id="NAME_2">^3</xliff:g>“ ar kitame įrenginyje."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formatuoti: <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Perkelti turinį į saugyklą (<xliff:g id="NAME">^1</xliff:g>)?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Perkeliant:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Neatjunkite saugyklos (<xliff:g id="NAME">^1</xliff:g>)"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Kai kurios programos neveiks"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Perkelti turinį"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Turinį perkelti vėliau"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Perkeliamas turinys…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Lėta saugykla (<xliff:g id="NAME">^1</xliff:g>)"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Vis tiek galite naudoti šią saugyklą („<xliff:g id="NAME_0">^1</xliff:g>“), bet ji gali veikti lėtai. \n\n„<xliff:g id="NAME_1">^2</xliff:g>“ saugomos programos gali neveikti tinkamai, o turinys gali būti perkeliamas ilgai. \n\nBandykite naudoti spartesnę saugyklą („<xliff:g id="NAME_2">^3</xliff:g>“) arba vietoj jos rinkitės nešiojamąją saugyklą („<xliff:g id="NAME_3">^4</xliff:g>“)."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Pradėti iš naujo"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Tęsti"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Galite pradėti naudodami „<xliff:g id="NAME">^1</xliff:g>“"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Galite pradėti naudodami „<xliff:g id="NAME">^1</xliff:g>“"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Galite pradėti naudodami „<xliff:g id="NAME">^1</xliff:g>“"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Akumuliatoriaus būsena"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Akumuliatoriaus lygis"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Bendruomenės"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Bendruomenės nustatymai"</string>
    <string name="satellite_setting" msgid="706846910912477125">"Palydoviniai pranešimai"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Redaguoti prieigos tašką"</string>
    <string name="apn_add" msgid="9069613192201630934">"Prieigos taško pridėjimas"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Nenustatyta"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Nenustatyta"</string>
    <string name="apn_name" msgid="6677695784108157953">"Pavadinimas"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Tarpinis serveris"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Prievadas"</string>
    <string name="apn_user" msgid="5831763936428279228">"Naudotojo vardas"</string>
    <string name="apn_password" msgid="7435086635953953029">"Slaptažodis"</string>
    <string name="apn_server" msgid="6997704279138388384">"Serveris"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"MMS tarpinis serveris"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"MMS prievadas"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MKC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Tapatybės nustatymo tipas"</string>
    <string name="apn_type" msgid="1835573305077788773">"APN tipas"</string>
    <string name="apn_protocol" msgid="181529867160380010">"APN protokolas"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"APN tarptinklinio ryšio protokolas"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Įgalinti / neleisti APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN įgalinta"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN neleidžiama"</string>
    <string name="bearer" msgid="3231443241639159358">"Nešiklis"</string>
    <string name="network_type" msgid="748590707422733595">"Tinklo tipas"</string>
    <string name="network_type_unspecified" msgid="7756349656194518725">"Nenurodyta"</string>
    <string name="mvno_type" msgid="4734654257494971247">"MVNO tipas"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"MVNO vertė"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Ištrinti APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"Naujas APN"</string>
    <string name="menu_save" msgid="6611465355127483100">"Išsaugoti"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Atšaukti"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_duplicate_apn_entry" msgid="7792928408935276618">"Tiksli APN įrašo kopija."</string>
    <string name="error_name_empty" msgid="1258275899283079142">"Pavadinimo laukas negali būti tuščias."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"APN negali būti tuščias."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"MKC lauke turi būti įvesti 3 skaitmenys."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"MNC lauke turi būti įvesti 2 ar 3 skaitmenys."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operatorius neleidžia pridėti %s tipo APN."</string>
    <string name="error_mmsc_valid" msgid="8380951905485647380">"MMSC laukas turi būti galiojantis."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Atkuriami numatytieji APN nustatymai."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Nustatyti iš naujo į numatytuosius nust."</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Numatytųjų APN nustatymų nustatymas iš naujo baigtas."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Nust. parinkt. iš naujo"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Iš naujo nustatyti mobiliojo ryšio tinklo nustatymus"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Bus iš naujo nustatyti visi mobiliojo ryšio tinklo nustatymai"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Iš naujo nustatyti mobiliojo ryšio tinklo nustatymus?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"„Bluetooth“ ir „Wi‑Fi“ ryšių nustatymas iš naujo"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Bus iš naujo nustatyti „Wi‑Fi“ ir „Bluetooth“ nustatymai. Negalite anuliuoti šio veiksmo."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Nustatyti iš naujo"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"„Bluetooth“ ir „Wi‑Fi“ ryšiai nustatyti iš naujo"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Ištrinti eSIM korteles"</string>
    <string name="reset_esim_desc" msgid="6125192435907740751">"Šiuo veiksmu nebus atšauktas jūsų mobiliojo ryšio planas. Jei norite gauti pakaitinę SIM kortelę, susisiekite su operatoriumi."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Nustatyti iš naujo"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Iš naujo nustatyti visus tinklo nustatymus? Negalite anuliuoti šio veiksmo."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Iš naujo nustatyti visus tinklo nustatymus ir ištrinti „eSIM“ korteles? Šio veiksmo anuliuoti negalima."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Nustatyti iš naujo"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Nustatyti iš naujo?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Šis naudotojas negali iš naujo nustatyti tinklo"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Tinklo nustatymai nustatyti iš naujo"</string>
    <string name="reset_esim_error_title" msgid="6516110227665862295">"Nepavyko ištrinti „eSIM“ kortelių"</string>
    <string name="reset_esim_error_msg" msgid="8459527827897797168">"Kažkas nepavyko ir „eSIM“ kortelės nebuvo ištrintos.\n\nIš naujo paleiskite įrenginį ir bandykite dar kartą."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Ištrinti visus duomenis (atkurti gamyklinius nustatymus)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Ištr. duom. (atk. gam. nust.)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Muzika"</li>\n<li>"Nuotraukos"</li>\n<li>"Kiti naudotojo duomenys"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"„eSIM“ kortelės"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Tai atlikus mobiliojo ryšio paslaugų planas nebus atšauktas."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Bus ištrinta visa asmens informacija ir atsisiųstos programos. Negalite anuliuoti šio veiksmo."</string>
    <string name="main_clear_final_desc_esim" msgid="6592404057237813989">"Bus ištrinta visa asmens informacija, įskaitant atsisiųstas programas ir „eSIM“ korteles. Negalite anuliuoti šio veiksmo."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Ištrinti visus duomenis?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Šis naudotojas negali atkurti gamyklinių nustatymų"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Ištrinama"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Palaukite…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Skambinimo nustatymai"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Nustatyti balso paštą, skambučio peradresavimą, skambučio laukimą, skambintojo ID"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"USB susiejimas"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Perkeliama aktyvioji sritis"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"„Bluetooth“ susiejimas"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Susiejimas"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Vieš. intern. pr. tšk. ir įreng. kaip modemo naud."</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Viešosios interneto prieigos taškas įjungtas, įrenginys naudojamas kaip modemas"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Viešosios interneto prieigos taškas įjungtas"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Įrenginio kaip modemo naudojimas"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Negalima naudoti įrenginio kaip modemo arba viešosios interneto prieigos taškų, kai įjungta Duomenų taupymo priemonė"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Tik viešosios interneto prieigos taškas"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Tik USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Tik „Bluetooth“"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Tik eternetas"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Viešosios interneto prieigos taškas, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Viešosios interneto prieigos taškas, „Bluetooth“"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Viešosios interneto prieigos taškas, eternetas"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, „Bluetooth“"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, eternetas"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"„Bluetooth“, eternetas"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Viešosios interneto prieigos taškas, USB, „Bluetooth“"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Viešosios interneto prieigos taškas, USB, eternetas"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Viešosios interneto prieigos taškas, „Bluetooth“, eternetas"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, „Bluetooth“, eternetas"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Viešosios interneto prieigos taškas, USB, „Bluetooth“, eternetas"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internetas nebendrinamas su kitais įrenginiais"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Išjungta"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"USB susiejimas"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"„Bluetooth“ susiejimas"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Eterneto susiejimas"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Naudodami viešosios interneto prieigos tašką ir įrenginį kaip modemą galite teikti internetą kitiems įrenginiams per mobiliojo ryšio duomenų tinklą. Be to, programos gali sukurti viešosios interneto prieigos tašką ir bendrinti turinį su netoliese esančiais įrenginiais."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Naudodami viešosios interneto prieigos tašką ir įrenginį kaip modemą galite teikti internetą kitiems įrenginiams „Wi-Fi“ arba mobiliųjų duomenų ryšiu. Be to, programos gali sukurti viešosios interneto prieigos tašką ir bendrinti turinį su netoliese esančiais įrenginiais."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Pagalba"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobiliojo ryšio tinklas"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"SMS programa"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Pakeisti SMS programą?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Naudoti „<xliff:g id="NEW_APP">%1$s</xliff:g>“ kaip SMS programą vietoj „<xliff:g id="CURRENT_APP">%2$s</xliff:g>“?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Naudoti „<xliff:g id="NEW_APP">%s</xliff:g>“ kaip SMS programą?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Pakeisti „Wi-Fi“ pagelbiklį?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Naudoti <xliff:g id="NEW_APP">%1$s</xliff:g> vietoje <xliff:g id="CURRENT_APP">%2$s</xliff:g> tinklo ryšiams tvarkyti?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Naudoti <xliff:g id="NEW_APP">%s</xliff:g> tinklo ryšiams tvarkyti?"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Pastarosios vietovės užklausos"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Darbo profilio vieta"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Programų leidimai pasiekti vietovės duomenis"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Vietovė išjungta"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{Vietovę gali pasiekti # programa iš {total}}one{Vietovę gali pasiekti # programa iš {total}}few{Vietovę gali pasiekti # programos iš {total}}many{Vietovę gali pasiekti # programos iš {total}}other{Vietovę gali pasiekti # programų iš {total}}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Naujausia prieiga"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Žiūrėti viską"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Žr. išsamią informaciją"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Nė viena programa pastaruoju metu nepateikė užklausų dėl vietovės"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Jokios programos neseniai nepasiekė vietovės"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Naudoja daug akum. energijos"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Naudoja mažai akum. energijos"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"„Wi‑Fi“ nuskaitymas"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Leisti programoms ir paslaugoms bet kuriuo metu nuskaityti ieškant „Wi‑Fi“ tinklų, net kai „Wi‑Fi“ išjungtas. Tai galima naudoti norint, pvz., tobulinti pagal vietovę teikiamas funkcijas ir paslaugas."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"„Bluetooth“ nuskaitymas"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Leisti programoms ir paslaugoms bet kuriuo metu nuskaityti ieškant netoliese esančių įrenginių, net kai „Bluetooth“ išjungtas. Tai galima naudoti norint, pvz., tobulinti pagal vietovę teikiamas funkcijas ir paslaugas."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Vietovės paslaugos"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Vietovės paslaugos"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Naudoti vietovę"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Laiko juostos nustatyti automatiškai nepavyko"</string>
    <string name="location_time_zone_detection_status_summary_degraded_by_settings" msgid="6198939835335841106"></string>
    <string name="location_time_zone_detection_status_summary_blocked_by_settings" msgid="5276280770344278768">"Vietovė arba Vietovės paslaugos išjungtos"</string>
    <string name="location_time_zone_detection_status_summary_blocked_by_environment" msgid="2279833212923765802"></string>
    <string name="location_time_zone_detection_status_summary_temporarily_unavailable" msgid="6586801403644278967"></string>
    <string name="location_time_zone_detection_location_is_off_dialog_title" msgid="231698690198001146">"Reikalinga įrenginio vietovė"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Jei norite nustatyti laiko juostą naudodami savo vietovę, įjunkite vietovės funkciją, tada atnaujinkite laiko juostos nustatymus"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Vietovės nustatymai"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Taisyti"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Atšaukti"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Automatinė laiko juosta išjungta"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Vietovės laiko juostos nustatymas išjungtas"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Vietovės laiko juostos nustatymas nepalaikomas"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Vietovės laiko juostos nustatymo pakeitimai neleidžiami"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Vietovės duomenys gali būti naudojami laiko juostai nustatyti"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Žiūrėti teisinę informaciją, būseną, programinės įrangos versiją"</string>
    <string name="legal_information" msgid="7509900979811934843">"Teisinė informacija"</string>
    <string name="manual" msgid="3651593989906084868">"Neautomatiškai"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Įstat. numatytos etiketės"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Saugos ir reguliavimo vadovas"</string>
    <string name="copyright_title" msgid="83245306827757857">"Autorių teisės"</string>
    <string name="license_title" msgid="8745742085916617540">"Licencija"</string>
    <string name="module_license_title" msgid="8705484239826702828">"„Google Play“ sistemos naujinių licencijos"</string>
    <string name="terms_title" msgid="2071742973672326073">"Taisyklės ir nuostatos"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Sistemos „WebView“ licencija"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Ekrano fono kreditai"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Palydovinių vaizdų teikėjai:\n© CNES / „Astrium“, „DigitalGlobe“, „Bluesky“, 2014 m."</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Neautomatiškai"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Įkeliant vadovą iškilo problema."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Trečiųjų šalių licencijos"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Įkeliant licencijas iškilo problema."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Įkeliama…"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Įkeliama…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Slaptažodžio nustatymas"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Darbo slaptažodžio nustatymas"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"PIN kodo nustatymas"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Darbo PIN kodo nustatymas"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Nustatykite atrakinimo piešinį"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Papildomai saugai užtikrinti nustatykite įrenginio atrakinimo piešinį"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Darbo atrakinimo piešinio nustatymas"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Nust. slapt., kad gal. naud. kont. kodą"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Nust. atrak. pieš., kad gal. naud. piršt. atsp."</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Kad apsaugotumėte įrenginį, nustatykite PIN kodą"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Nus. PIN kodą, kad gal. naud. kon. kodą"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Įveskite slaptažodį iš naujo"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Pakartotinai įveskite darbo slaptažodį"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Įveskite darbo profilio slaptažodį"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Patvirtinkite piešinį"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Nubr. darbo prof. atr. piešinį"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Įveskite PIN kodą iš naujo"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Pakartotinai įveskite PIN kodą"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Įveskite darbo profilio PIN kodą"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Slaptažodžiai neatitinka"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PIN kodai neatitinka"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Nupieškite atrakinimo piešinį dar kartą"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Atrakinimo pasirinkimas"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Slaptažodis nustatytas"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"PIN kodas nustatytas"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Modelis nustatytas"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Norėdami naudoti atrakinimą pagal veidą, nustatykite slaptažodį"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Norėdami naudoti atrakinimą pagal veidą, nustatykite atrakinimo piešinį"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Norėdami naudoti atrakinimą pagal veidą, nustatykite PIN kodą"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Nustatykite veido ar piršto atspaudo naudojimo slaptažodį"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Nustatykite veido ar kontrolinio kodo naudojimą atrakinantį piešinį"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Nustatykite veido ar piršto antspaudo naudojimo PIN kodą"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Pamiršote slaptažodį?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Pamiršote atrakinimo piešinį?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Pamiršote PIN kodą?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Tęskite nupiešę atrakinimo piešinį"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Tęskite įvedę PIN kodą"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Tęskite įvedę slaptažodį"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Tęskite nupiešę darbo atrakinimo piešinį"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Jei norite tęsti, įveskite darbo PIN kodą"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Jei norite tęsti, įveskite darbo slaptažodį"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Kad dar labiau apsaugotumėte įrenginį, naudokite įrenginio atrakinimo piešinį"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Kad dar labiau apsaugotumėte įrenginį, įveskite įrenginio PIN kodą"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Kad dar labiau apsaugotumėte įrenginį, įveskite įrenginio slaptažodį"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Kad dar labiau apsaugotumėte įrenginį, naudokite darbo profilio atrakinimo piešinį"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Kad dar labiau apsaugotumėte įrenginį, įveskite darbo profilio PIN kodą"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Kad dar labiau apsaugotumėte įrenginį, įveskite darbo profilio slaptažodį"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Patvirtinkite atrakinimo piešinį"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Patvirtinkite PIN kodą"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Patvirtinkite slaptažodį"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Tapatybės patvirtinimas"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Jei norite perkelti „Google“ paskyras, nustatymus ir kt., įveskite kito įrenginio atrakinimo piešinį. Atrakinimo piešinys šifruotas."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Jei norite perkelti „Google“ paskyras, nustatymus ir kt., įveskite kito įrenginio PIN kodą. PIN kodas šifruotas."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Jei norite perkelti „Google“ paskyras, nustatymus ir kt., įveskite kito įrenginio slaptažodį. Slaptažodis šifruotas."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Įrenginį atrakinkite ir atrakinimo piešiniu"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Įrenginį atrakinkite ir PIN kodu"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Įrenginį atrakinkite ir slaptažodžiu"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Patvirtinkite atrakinimo piešinį"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Patvirtinkite PIN kodą"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Patvirtinkite slaptažodį"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Jei norite tęsti, naudokite įrenginio atrakinimo piešinį"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Jei norite tęsti, įveskite įrenginio PIN kodą"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Jei norite tęsti, įveskite įrenginio slaptažodį"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Netinkamas PIN kodas"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Netinkamas slaptažodis"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Netinkamas piešinys"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Pagalbos tarnyba"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Įrenginio sauga"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Keisti atrakinimo modelį"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Pakeisti atrakinimo PIN kodą"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Nubrėžkite atrakinimo piešinį"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Jei norite gauti pagalbos, paspauskite „Meniu“."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Baigę atleiskite pirštą"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Sujunkite mažiausiai <xliff:g id="NUMBER">%d</xliff:g> tašk. Bandykite dar kartą."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Piešinys įrašytas"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Darkart nupieškite, kad patvirtintumėte"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Naujas atrakinimo piešinys"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Patvirtinti"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Nustatyti iš naujo"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Išvalyti"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Tęsti"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Atrakinimo modelis"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Reikalauti modelio"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Jei norite atrakinti ekraną, reikia nustatyti modelį"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Padaryti piešinį matomą"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Patobulintas PIN kodu užtikrinamas privatumas"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Išjungti animacijas įvedant PIN kodą"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Padaryti profilio atrakinimo piešinį matomą"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibruoti palietus"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Maitin. myg. iškart užrakin."</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Išskyrus atvejus, kai „<xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>“ laiko jį atrakintą"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Nustatyti atrakinimo modelį"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Keisti atrakinimo modelį"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Kaip nustatyti atrakinimo modelį"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Per daug klaidingų bandymų. Bandykite dar kartą po <xliff:g id="NUMBER">%d</xliff:g> sek."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Programa jūsų telefone neįdiegta."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Darbo profilio sauga"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Darbo profilio ekrano užraktas"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Naudoti vieną užraktą"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Naudokite vieną darbo profilio ir įrenginio ekrano užraktą"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Naudoti vieną užraktą?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Įrenginyje bus naudojamas darbo profilio ekrano užraktas. Abiems profiliams bus taikoma darbo profilio politika."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Darbo profilio užraktas neatitinka organizacijos saugos reikalavimų. Galite naudoti tą patį įrenginio ekrano ir darbo profilio užraktą, bet bus taikomi visi darbo užrakto politikos nustatymai."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Naudoti vieną užraktą"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Naudoti vieną užraktą"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Toks pats kaip įrenginio ekrano užraktas"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Valdyti programas"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Programos informacija"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Programos nustatymai"</string>
    <string name="install_applications" msgid="3921609656584369901">"Nežinomi šaltiniai"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Leisti visus progr. šaltinius"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Neseniai atidarytos programos"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Žr. visas programas}one{Žr. visas # programą}few{Žr. visas # programas}many{Žr. visas # programos}other{Žr. visas # programų}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Susisiekimas su IT administratoriumi"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Jie gali padėti iš naujo nustatyti PIN kodą, atrakinimo piešinį arba slaptažodį"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Išplėstiniai nustatymai"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Įgalinti daugiau nustatymų parinkčių"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Programos informacija"</string>
    <string name="storage_label" msgid="2522307545547515733">"Saugykla"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Atidaryti pagal numatytuosius nustatymus"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Numatytieji"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Ekrano suderinamumas"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Leidimai"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Talpykla"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Išvalyti talpyklą"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Talpykla"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{Vienas elementas}one{# elementas}few{# elementai}many{# elemento}other{# elementų}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Išvalyti prieigą"</string>
    <string name="controls_label" msgid="8671492254263626383">"Valdikliai"</string>
    <string name="force_stop" msgid="2681771622136916280">"Sustabdyti"</string>
    <string name="archive" msgid="9074663845068632127">"Archyvuoti"</string>
    <string name="restore" msgid="7622486640713967157">"Atkurti"</string>
    <string name="restoring_step_one" msgid="3465050101254272874">"Atkuriama"</string>
    <string name="restoring_step_two" msgid="140484846432595108">"Atkuriama."</string>
    <string name="restoring_step_three" msgid="3712883580876329811">"Atkuriama…"</string>
    <string name="restoring_step_four" msgid="8966846882470446209">"Atkuriama..."</string>
    <string name="total_size_label" msgid="2052185048749658866">"Iš viso"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Programos dydis"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"USB atminties programa"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Naudotojo duomenys"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Pašalinti"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Pašalinti visiems naudotojams"</string>
    <string name="install_text" msgid="4558333621516996473">"Įdiegti"</string>
    <string name="disable_text" msgid="5146002260857428005">"Išjungti"</string>
    <string name="enable_text" msgid="8570798764647110430">"Įgalinti"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Išvalyti saugyklą"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Pašalinti naujinius"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Leisti apribotus nustatymus"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Kai kurios jūsų pasirinktos veiklos atidaromos šioje programoje pagal numatytuosius nustatymus."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Pasirinkote leisti šiai programai kurti valdiklius ir pasiekti jų duomenis."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Nenustatyti jokie numatytieji nustatymai."</string>
    <string name="clear_activities" msgid="488089228657585700">"Išvalyti numatytąsias nuostatas"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Ši programa gali būti nepritaikyta jūsų ekranui. Čia galite valdyti jos pritaikymą pagal ekraną."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Paklausti, kai paleidžiama"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Keisti programos mastelį"</string>
    <string name="unknown" msgid="8192160131923461175">"Nežinomas"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Rūšiuoti pagal pavadinimą"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Rūšiuoti pagal dydį"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Naujausios"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Dažniausios"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Rodyti vykdomas paslaugas"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Rodyti padėtus procesus"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Avarinė programa"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Iš naujo nustat. nuostat."</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Iš naujo nust. nuostat.?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Bus iš naujo nustatytos visos nurodytų elementų nuostatos:\n\n"<li>"išjungtos programos;"</li>\n<li>"išjungti programų pranešimai;"</li>\n<li>"numatytosios veiksmų programos;"</li>\n<li>"programų foninių duomenų apribojimai;"</li>\n<li>"visi leidimų apribojimai;"</li>\n<li>"akumuliatoriaus energijos vartojimo nustatymai."</li>\n\n"Neprarasite jokių programų duomenų."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Iš naujo nustat. program."</string>
    <string name="filter" msgid="9039576690686251462">"Filtruoti"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Pasirinkti filtro parinktis"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Visos programos"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Išjungtos programos"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Atsisiųsta"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Vykdoma"</string>
    <string name="not_installed" msgid="5074606858798519449">"Neįdiegta šiam naudotojui"</string>
    <string name="installed" msgid="2837449358488825884">"Įdiegta"</string>
    <string name="no_applications" msgid="985069304755391640">"Nėra programų"</string>
    <string name="internal_storage" msgid="999496851424448809">"Vidinė atmint."</string>
    <string name="recompute_size" msgid="1098091228370999128">"Iš naujo apskaičiuojamas dydis..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Ištrinti programos duomenis?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Šios programos duomenys, įskaitant failus ir nustatymus, bus visam laikui ištrinti iš šio įrenginio"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"Gerai"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Atšaukti"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Ištrinti"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Programa nerasta įdiegtų programų sąraše."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Nepavyko išvalyti programos saugyklos."</string>
    <string name="computing_size" msgid="4915310659841174866">"Apskaičiuojama..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Nepavyko apskaičiuoti paketo dydžio."</string>
    <string name="version_text" msgid="7628938665256107608">"<xliff:g id="VERSION_NUM">%1$s</xliff:g> versija"</string>
    <string name="move_app" msgid="5421158479447276791">"Perkelti"</string>
    <string name="archiving_failed" msgid="2037798988961634978">"Nepavyko archyvuoti"</string>
    <string name="archiving_succeeded" msgid="7891249456483297845">"Suarchyvuota <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="restoring_failed" msgid="3390531747355943533">"Nepavyko atkurti"</string>
    <string name="restoring_in_progress" msgid="7787443682651146115">"Atkuriama „<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>“"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Jau vykdomas kitas perkėlimas."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Nėra pakankamai vietos atmintinėje."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Programos nėra."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Diegimo vieta netinkama."</string>
    <string name="system_package" msgid="7559476279008519360">"Sistemos naujinių negalima įdiegti išorinėje medijoje."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Įrenginio administravimo programos negalima įdiegti išorinėje laikmenoje"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Priverstinai sustabdyti?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Jei priverstinai sustabdysite programą, ji gali neveikti tinkamai."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Išjungti programą"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Jei išjungsite šią programą, „Android“ ir kitos programos gali neveikti, kaip numatyta. Atminkite, kad negalite ištrinti šios programos, nes ji buvo iš anksto įdiegta įrenginyje. Išjungę išjungsite šią programą ir paslėpsite ją įrenginyje."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Parduotuvė"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Išsami programos informacija"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Programa įdiegta iš <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Daugiau informacijos apie „<xliff:g id="APP_STORE">%1$s</xliff:g>“"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Vykdoma"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Niekada nenaudota)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Atmintinės naudojimas"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Paleidžiama iš naujo"</string>
    <string name="cached" msgid="5379485147573438201">"Padėtas fono procesas"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Niekas nevykdoma."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Paleista programos."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"<xliff:g id="MEMORY">%1$s</xliff:g> laisva"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"Panaudota <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Naudotojas: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Pašalintas naudotojas"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<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="1209371773353932361">"<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="8957061449107822282">"<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="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesai (-ų) ir <xliff:g id="NUMSERVICES">%2$d</xliff:g> paslaugos (-ų)"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Įrenginio atmintinė"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Laisvosios prieigos atminties naudojimas"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sistema"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Programos"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Nenaudojama"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Naudojama"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Išsaugota talpykloje"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> laisvosios prieigos atminties"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Vykdoma programa"</string>
    <string name="no_services" msgid="3898812785511572899">"Neaktyvu"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Paslaugos"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Procesai"</string>
    <string name="service_stop" msgid="5712522600201308795">"Sustabdyti"</string>
    <string name="service_manage" msgid="3896322986828332075">"Nustatymai"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Ši paslauga buvo pradėta jos programos. Ją sustabdžius gali atsirasti programos trikčių."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Šios programos negalima saugiai sustabdyti. Jei ją sustabdysite, galite prarasti dalį esamo darbo."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"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="6615788996428486121">"„<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="6685973937935027773">"Pagrindinis naudojamas procesas."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"„<xliff:g id="COMP_NAME">%1$s</xliff:g>“ paslauga naudojama."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"„<xliff:g id="COMP_NAME">%1$s</xliff:g>“ teikėjas naudojamas."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Sustabdyti sistemos aptarnavimą?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Kalbos, įvestis ir gestai"</string>
    <string name="language_settings" msgid="8700174277543875046">"Kalbos ir įvestis"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Kalbos"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Klaviatūra"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Neturite leidimo keisti įrenginio kalbos."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Kalbos ir įvestis"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Įrankiai"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Klaviatūra ir įvesties metodai"</string>
    <string name="system_language" msgid="1146762166579643257">"Sistemos kalbos"</string>
    <string name="phone_language" msgid="5986939176239963826">"Kalbos"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automatiškai pakeisti"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Taisyti blogai įvestus žodžius"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Automatinis didžiųjų raidžių rašymas"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Pirmą sakinių raidę rašyti iš didžiosios"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automatiškai dėti skyrybos ženklus"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Fiziniai klaviatūros nustatymai"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Du kartus paspauskite tarpo klavišą, kad įterptumėte „.“"</string>
    <string name="show_password" msgid="7101900779571040117">"Rodyti slaptažodžius"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Trumpai rodyti simbolius vedant tekstą"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"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="6449414356743946577">"Nustatymai"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Kalba"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Klaviatūros"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Ekrano klaviatūra"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Pasiekiama ekrano klaviatūra"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Tvarkyti ekrano klaviatūras"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Parinktys"</string>
    <string name="keyboard_a11y_category" msgid="8230758278046841469">"Pritaikomumas"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fizinė klaviatūra"</string>
    <string name="show_ime" msgid="4334255501724746849">"Ekrano klaviatūros naudojimas"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Palikti ekrane, kol fizinė klaviatūra aktyvi"</string>
    <string name="bounce_keys" msgid="7419450970351743904">"Peradresavimo klavišai"</string>
    <string name="bounce_keys_summary" msgid="6922850403920596246">"Įgalinkite peradresavimo klavišus, kad pritaikytumėte fizinę klaviatūrą"</string>
    <string name="slow_keys" msgid="2891452895499690837">"Lėtieji klavišai"</string>
    <string name="slow_keys_summary" msgid="6147992959180167575">"Įgalinkite lėtuosius klavišus, kad pritaikytumėte fizinę klaviatūrą"</string>
    <string name="sticky_keys" msgid="7317317044898161747">"Atmenieji klavišai"</string>
    <string name="sticky_keys_summary" msgid="8520909829540989765">"Įgalinkite atmenuosius klavišus, kad pritaikytumėte fizinę klaviatūrą"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Spartieji klavišai"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Rodyti sparčiųjų klavišų sąrašą"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Darbo profilio klaviatūros ir įrankiai"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Darbui skirta ekrano klaviatūra"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Numatytasis"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Jutiklinė dalis"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Jutiklinė dalis ir pelė"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Žymiklio greitis, gestai"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Palieskite ir spustelėkite"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Jutiklinės dalies gestai"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Tinkinti individualūs jutiklinės dalies naršymo gestai"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Atvirkštinis slinkimas"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Slenkant turinys juda į viršų"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Palietus apačioje dešinėje"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Daugiau – palietus jutiklinės dalies apačioje dešinėje"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Žymiklio greitis"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Sužinokite jutiklinės dalies gestus"</string>
    <!-- no translation found for keywords_touchpad (8159846254066666032) -->
    <skip />
    <!-- no translation found for keywords_trackpad_bottom_right_tap (1285062446073929305) -->
    <skip />
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Eikite į pagrindinį puslapį"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Braukite viršun trimis pirštais bet kur jutiklinėje dalyje"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Grįžti"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Perbraukite iš kairės ar dešinės trimis pirštais"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Paskutinių programų peržiūra"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Braukite viršun trimis pirštais, palaikykite ir paleiskite"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Žr. praneš. ir sparčiuosius nustat."</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Braukite žemyn trimis pirštais pagrindiniame ekrane"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Programų perjungimas"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Perbraukite į kairę ar dešinę keturiais pirštais"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Praleisti"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Kitas"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Paleisti"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Atlikta"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Grįžti"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Perbraukite į kairę ar dešinę trimis pirštais"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Eikite į pagrindinį puslapį"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Perbraukite į viršų trimis pirštais"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Naujausios programos"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Perbraukite į viršų trimis pirštais ir palaikykite"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Pranešimai"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Perbraukite į apačią trimis pirštais"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Perjunkite programas"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Perbraukite į kairę ar dešinę keturiais pirštais"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Modifikavimo klavišai"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Klavišų funkcijų keitimas"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Nustatyti viską iš naujo"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Numatytasis"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Ar tikrai norite iš naujo nustatyti visus modifikavimo klavišus į numatytuosius?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Atlikta"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Atšaukti"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Nust. iš naujo"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Pasirinkite modifikavimo klavišą"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Pasirinkite naują „<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>“ slaptažodį:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Numatytasis"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Kalba"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Žymiklio greitis"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Žaidimų valdiklis"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Nukreipti vibravimą"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Siųsti vibraciją į žaidimų valdiklį, kai jis prijungtas"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Pasirinkite klaviatūros išdėstymą"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Nustatyti klaviatūros išdėstymus"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Kad perj., pasp. vald. ir tarpo kl."</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Numatytasis"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Klaviatūros išdėstymai"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Fizinės klaviatūros išdėstymas"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Asmeninis žodynas"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Asmeninis darbo žodynas"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Pridėkite žodžių, kurie bus naudojami programose, pvz., naudojant rašybos tikrinimo funkciją"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Pridėti"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Pridėti prie žodyno"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Frazė"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Daugiau parink."</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Mažiau parink."</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"Gerai"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Žodis:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Spartusis klavišas:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Kalba:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Įveskite žodį"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Pasirenkamas spart. klavišas"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Redaguoti žodį"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Redaguoti"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Ištrinti"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Neturite jokių žodžių naudotojo žodyne. Kad pridėtumėte žodį, palieskite mygtuką „Pridėti“ (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Visos kalbos"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Daugiau kalbų..."</string>
    <string name="testing" msgid="6294172343766732037">"Bandymas"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Ekrano klaviatūra, įrankiai"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Ekrano klaviatūra, fizinė klaviatūra, įrankiai"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fizinė klaviatūra"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Išdėstymas"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Pasirinkti programėlę"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Pasirinkti valdiklį"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Sukurti valdiklį ir leisti prieigą?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Sukūrus valdiklį, programa galės pasiekti visus pateikiamus duomenis.\n\nPrograma: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nValdiklis: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Visada leisti „<xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>“ kurti valdiklius ir pasiekti jų duomenis"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Naudojimo statistika"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Rūšiuoti pagal naudojimo laiką"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Rūšiuoti pagal pastarąjį naudojimą"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Rūšiuoti pagal programos pavadinimą"</string>
    <string name="last_time_used_label" msgid="7589377271406011659">"Paskutinį kartą naudota"</string>
    <string name="last_time_used_never" msgid="2936073559267990034">"niekada"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Naudojimo laikas"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Pritaikymas neįgal."</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Pasiekiamumo nustatymai"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Ekranas, sąveika, garsas"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Matomumo nustatymai"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Galite tinkinti šį įrenginį pagal savo poreikius. Vėliau šias pritaikymo neįgaliesiems funkcijas galite pakeisti nustatymuose."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Pakeisti šrifto dydį"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Ekrano skaitytuvas"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Subtitrai"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Garsas"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Bendrieji"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Ekranas"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Spalva ir judesys"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ekrano tamsinimas"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Sąveikos valdikliai"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Laiko valdikliai"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Sistemos valdikliai"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Atsisiųstos programos"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Eksperimentinė versija"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Funkcijų žymos"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"„Bluetooth“ HCI šnipinėjimo žurnalo filtravimas"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Nustatyti filtrus"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Išjunkite ir įjunkite „Bluetooth“, kad pakeitimai įsigaliotų"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"„Bluetooth“ HCI šnipinėjimo žurnalo filtravimo PBAP"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"„Bluetooth“ HCI šnipinėjimo žurnalo filtravimo MAP"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Nustatyti filtravimo režimą. (Išjunkite ir įjunkite „Bluetooth“, kad pakeitimai įsigaliotų)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Pakeiskite šią parinktį nustatę „Bluetooth“ HCI šnipinėjimo žurnalo režimą į „Įgalinta filtruota“"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Ekrano skaitytuvas pirmiausia skirtas akliems ar regos sutrikimų turintiems žmonėms"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Palieskite elementus ekrane, kad jie būtų skaitomi balsu"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Subtitrų nuostatos"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Apie subtitrų nuostatas"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Sužinokite daugiau apie subtitrų nuostatas"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Didinimas"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Didinimo spartusis klavišas"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Vedamo teksto didinimas"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Didinimo priemonė automatiškai atitinka vedamą tekstą"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Palikti įjungtą perjungiant programas"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Didinimo funkcija lieka įjungta ir tolinama perjungiant programas"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Vairasvirtė"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Suaktyvinkite ir judinkite didinimo funkciją vairalazde ekrane. Palieskite ir palaikykite, tada valdykite didinimo funkciją vilkdami vairasvirtę. Norėdami judinti pačią vairasvirtę, palieskite ir vilkite."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Apie didinimą"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Sužinokite daugiau apie didinimą"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Didinimo tipas"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Viso ekrano, konkrečios srities didinimas arba abiejų parinkčių perjungimas"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Visas ekranas"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Dalis ekrano"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Perjunkite iš viso į dalį ekrano ir atvirkščiai"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Didinimo parinkties pasirinkimas"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Viso ekrano didinimas"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Didinti ekrano dalį"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Perjunkite iš viso į dalį ekrano ir atvirkščiai"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Tarp abiejų parinkčių galite judėti paliesdami perjungimo mygtuką"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Perjungti į pritaikomumo mygtuką?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Jei didinsite ekrano dalį naudodami palietimo tris kartus funkciją, įvesties ir kiti veiksmai vėluos.\n\nPritaikomumo mygtukas bus pateiktas kaip slankusis mygtukas virš kitų programų. Palieskite, kad padidintumėte."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Perjungti į pritaikomumo mygtuką"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Palietimo tris kartus funkcijos naudojimas"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Klaviatūra gali veikti lėčiau"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Jei didinate dalį ekrano vaizdo triskart paliesdami, galite pastebėti su klaviatūra susijusių problemų.\n\nKad to išvengtumėte, galite pakeisti didinimo spartųjį klavišą iš palietimo tris kartus į kitą parinktį.\n"<annotation id="link">"Keisti nustatymą"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Vis tiek tęsti"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Atšaukti"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Didinimo nustatymai"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Didinimas naudojant spart. klavišą"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Didinti naud. spart. klav. ir palietus tris kartus"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Apie „<xliff:g id="SERVICE">%1$s</xliff:g>“"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Ekrano dydis ir tekstas"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Teksto rodymo keitimas"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Tema: karšto oro balionų dizainas"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Nuo: Bill"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Labas rytas!\n\nNoriu pasiteirauti, kaip sekasi kurti projektus. Ar jie bus parengti, kol pradėsime kurti naujus balionėlius?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Nust. nustatymus iš naujo"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Pateikties dydžio ir teksto nustatymai nustatyti iš naujo"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Iš naujo nustatyti ekrano dydį ir tekstą?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Nustatyti iš naujo"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Turite planų savaitgaliui?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Vyksime į paplūdimį. Norite prisijungti?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Parinktys"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Ekrano artinimas"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Palieskite 3 kartus, kad keistumėte mastelį."</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Palieskite mygtuką, kad keistumėte mastelį"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Sparčiai artinkite ekrane, kad turinys būtų didesnis"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Kad priartintumėte, atlikite toliau nurodytus veiksmus.&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Paleiskite didinimo funkciją sparčiuoju klavišu.&lt;br/&gt; {1,number,integer}. Palieskite ekraną.&lt;br/&gt; {2,number,integer}. Pereikite nuo vieno ekrano elemento prie kito vilkdami dviem pirštais.&lt;br/&gt; {3,number,integer}. Koreguokite mastelį suėmę dviem pirštais.&lt;br/&gt; {4,number,integer}. Sustabdykite didinimo funkciją sparčiuoju klavišu.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Kad laikinai priartintumėte, atlikite toliau nurodytus veiksmus.&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Įsitikinkite, kad didinimo tipas nustatytas į viso ekrano.&lt;br/&gt; {1,number,integer}. Paleiskite didinimo funkciją sparčiuoju klavišu.&lt;br/&gt; {2,number,integer}. Palieskite ir palaikykite bet kurią ekrano vietą.&lt;br/&gt; {3,number,integer}. Pereikite nuo vieno ekrano elemento prie kito vilkdami pirštu.&lt;br/&gt; {4,number,integer}. Sustabdykite didinimo funkciją pakeldami pirštą."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Kai didinimas įjungtas, galite artinti ekraną.\n\n"<b>"Jei norite keisti mastelį,"</b>", įjunkite didinimą, tada palieskite bet kurioje ekrano vietoje.\n"<ul><li>"Slinkite vilkdami dviem ar daugiau pirštų"</li>\n<li>"Koreguokite mastelį suimdami dviem ar daugiau pirštų"</li></ul>\n\n<b>"Jei norite laikinai pakeisti mastelį"</b>", įjunkite didinimą, tada palieskite ir palaikykite bet kurioje ekrano vietoje.\n"<ul><li>"Naršykite ekraną vilkdami pirštu"</li>\n<li>"Pakelkite pirštą, kad tolintumėte"</li></ul>\n\n"Negalite artinti naudodami klaviatūrą ar naršymo juostą."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"<xliff:g id="CURRENT_PAGE">%1$d</xliff:g> psl. iš <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Naudokite pritaikomumo mygtuką, kad atidarytumėte"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Norėdami atidaryti, palaikykite garsumo klavišus"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Norėdami atidaryti, triskart palieskite ekraną"</string>
    <string name="accessibility_tutorial_dialog_title_two_finger_double" msgid="3912970760484557646">"Atidarymas palietus ekraną du kartus dviem pirštais"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Naudokite gestą, kad atidarytumėte"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Pritaikomumo gesto naudojimas"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Norėdami naudoti šią funkciją, ekrano apačioje palieskite pritaikomumo mygtuką <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nJei norite perjungti funkcijas, palieskite ir palaikykite pritaikomumo mygtuką."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Jei norite naudoti šią funkciją, palieskite pritaikomumo mygtuką ekrane."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Norėdami naudoti šią funkciją, paspauskite ir palaikykite abu garsumo klavišus."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Norėdami pradėti ar baigti didinti, triskart palieskite bet kur ekrane."</string>
    <string name="accessibility_tutorial_dialog_message_two_finger_triple" msgid="860548190334486449">"Jei norite pradėti ar baigti didinti, dukart palieskite bet kurioje ekrano vietoje dviem pirštais."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Norėdami naudoti šią funkciją, perbraukite dviem pirštais aukštyn nuo ekrano apačios.\n\nJei norite perjungti funkcijas, perbraukite aukštyn dviem pirštais ir palaikykite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Norėdami naudoti šią funkciją, perbraukite trimis pirštais aukštyn nuo ekrano apačios.\n\nJei norite perjungti funkcijas, perbraukite aukštyn trimis pirštais ir palaikykite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Norėdami naudoti pritaikymo neįgaliesiems funkciją, perbraukite dviem pirštais aukštyn nuo ekrano apačios.\n\nJei norite perjungti funkcijas, perbraukite aukštyn dviem pirštais ir palaikykite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Norėdami naudoti pritaikymo neįgaliesiems funkciją, perbraukite trimis pirštais aukštyn nuo ekrano apačios.\n\nJei norite perjungti funkcijas, perbraukite aukštyn trimis pirštais ir palaikykite."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Supratau"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="6797349445794031781">"Mygtuko nustatymai"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Spartusis klavišas: <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Pritaikomumo mygtukas"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Pritaikomumo gestas"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Perbraukimas aukštyn dviem pirštais"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Perbraukimas aukštyn trim pirštais"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Paliesti pritaikomumo mygtuką"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Pritaikomumo gesto naudojimas"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Palieskite ekrano apačioje esantį pritaikomumo mygtuką <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nJei norite perjungti funkcijas, palieskite ir palaikykite pritaikomumo mygtuką."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Perbraukite aukštyn dviem pirštais nuo ekrano apačios.\n\nJei norite perjungti funkcijas, perbraukite aukštyn dviem pirštais ir palaikykite."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Perbraukite aukštyn trimis pirštais nuo ekrano apačios.\n\nJei norite perjungti funkcijas, perbraukite aukštyn trimis pirštais ir palaikykite."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Daugiau parinkčių"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Sužinokite daugiau apie paslaugą „<xliff:g id="SERVICE">%1$s</xliff:g>“"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Laikyti garsumo klavišus"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"laikyti garsumo klavišus"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Paspauskite ir palaikykite abu garsumo klavišus"</string>
    <string name="accessibility_shortcut_edit_dialog_title_two_finger_double_tap" msgid="2271778556854020996">"Dukart palieskite ekraną dviem pirštais"</string>
    <string name="accessibility_shortcut_two_finger_double_tap_keyword" msgid="2971265341474137433">"dukart palieskite ekraną dviem pirštais"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_two_finger_double_tap" msgid="8262165091808318538">"Greitai palieskite ekraną {0,number,integer} k. dviem pirštais"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Ekrano palietimas tris kartus"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"triskart paliesti ekraną"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Sparčiai palieskite ekraną {0,number,integer} k. Dėl šio sparčiojo klavišo įrenginys gali veikti lėčiau"</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Išplėstin."</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Pritaikymo mobiliesiems mygtukas nustatytas į „<xliff:g id="SERVICE">%1$s</xliff:g>“. Jei norite naudoti didinimo funkciją, palieskite ir palaikykite pritaikymo neįgaliesiems mygtuką, tada pasirinkite didinimo funkciją."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Pritaikomumo gestas nustatytas į „<xliff:g id="SERVICE">%1$s</xliff:g>“. Norėdami naudoti didinimą, perbraukite dviem pirštais iš ekrano apačios ir palaikykite. Tada pasirinkite didinimą."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Garsumo spart. klavišas"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Sparčiųjų klavišų nustatymai"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Spart. klavišas užrakinimo ekrane"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Leidžiama įjungti funkcijos spartųjį klavišą užrakinimo ekrane. Paspauskite abu garsumo klavišus ir palaikykite kelias sekundes."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Pritaikomumo mygtukas"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Pritaikomumo mygtukas ir gestas"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Sparčiai pasiekite pritaikymo neįgaliesiems funkcijas bet kuriame ekrane"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Apie pritaikomumo mygtuką"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Apie pritaikomumo mygtuką ir gestą"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Sužinokite daugiau apie pritaikomumo mygtuką ir gestą"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Pritaikomumo mygtuko naudojimas. Gestas nepasiekiamas naudojant naršymą 3 mygtukais."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Greitai pasiekti pritaik. neįgaliesiems funkcijas"</string>
    <string name="accessibility_button_gesture_description" msgid="1141723096904904336">"&lt;b&gt;Kad pradėtumėte, atlikite toliau nurodytus veiksmus&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Eikite į pritaikomumo nustatymus&lt;br/&gt; {1,number,integer}. Pasirinkite funkciją ir palieskite spartųjį klavišą&lt;br/&gt; {2,number,integer}. Pasirinkite, norite naudoti mygtuką ar gestą, kad pasiektumėte funkciją.&lt;br/&gt;"</string>
    <string name="accessibility_button_description" msgid="7669538706120092399">"&lt;b&gt;Kad pradėtumėte, atlikite toliau nurodytus veiksmus&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Eikite į pritaikomumo nustatymus&lt;br/&gt; {1,number,integer}. Pasirinkite funkciją ir palieskite spartųjį klavišą&lt;br/&gt; {2,number,integer}. Pasirinkite mygtuką, kuriuo norite pasiekti funkciją.&lt;br/&gt;"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Naudoti mygtuką arba gestą"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Vieta"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Dydis"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Išblunka, kai nenaudojamas"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Po kelių sekundžių išblunka, kad geriau matytumėte ekraną"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Skaidrumas, kai nenaudojamas"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Skaidrus"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Neskaidrus"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Didelio kontrasto tekstas"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Keiskite teksto spalvą į juodą arba baltą. Nustatykite didžiausią kontrastą su fonu."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Automat. atnaujinti ekrano didinimą"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Atnaujinti ekrano didinimą perkeliant programas"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Maitinimo mygt. baig. skamb."</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Didelis pelės žymeklis"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Padarykite pelės žymeklį geriau matomą"</string>
    <string name="accessibility_force_invert_title" msgid="5015366813138748407">"Padaryti visas programas tamsias"</string>
    <string name="accessibility_force_invert_summary" msgid="1882329675950887268">"Taikoma programoms be tamsiosios temos. Kai kuriose programose gali būti klaidų, pvz., pakeistos spalvos."</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Pašalinti animacijas"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Sumažinkite judėjimą ekrane"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Monofoninis garsas"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Sujungti kanalus leidžiant garsą"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Garso balansas"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Kairysis"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Dešinysis"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Numatytasis"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sek."</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sek."</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 min."</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 min."</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Veiksmo laikas (prit. neįg. skirt. laikas)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Apie veiksmui atlikti skirtą laiką (pritaikomumui skirtas laikas)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Sužinokite daugiau apie veiksmui atlikti skirtą laiką (pritaikomumui skirtas laikas)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Laikas, skirtas veiksmams atlikti"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Ši skirtojo laiko nuostata palaikoma ne visose programose"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Pasirinkite, kiek laiko rodyti laikinus pranešimus, kuriuose prašoma atlikti veiksmus"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"„Paliesti ir laikyti“ delsa"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Spalvų inversija"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Naudoti spalvų inversiją"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Spartusis klavišas: Spalvų inversija"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Naudojant spalvų inversiją šviesūs ekranai pakeičiami tamsiais. Be to, tamsūs ekranai pakeičiami šviesiais."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Atminkite&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Bus pakeistos medijos ir vaizdų spalvos.&lt;/li&gt; &lt;li&gt; Spalvų inversija veikia visose programose.&lt;/li&gt; &lt;li&gt; Kad būtų rodomas tamsus fonas, galite naudoti Tamsiąją temą.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"įvestumėte nustatymus"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Aut. paspaud. (neveikos trukmė)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Apie autom. pasp. (neveikos trukmė)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Sužinokite daugiau apie automatinį paspaudimą (neveikos trukmė)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Galite nustatyti, kad susietos pelės mygtukas būtų spustelimas automatiškai, kai žymeklis nejuda tam tikrą laiką"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Automatinis paspaudimas gali būti naudingas, jei sudėtinga paspausti pelės mygtukus"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Automatinis paspaudimas išjungtas"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Trumpas"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sek."</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Vidutinis"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sek."</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Ilgas"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sek."</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Tinkintas"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Trumpesnis"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Ilgesnis"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Automatinio paspaudimo laikas"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibravimas ir lietimo technologija"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Valdyti vibravimo stiprumą skirtingais naudojimo atvejais"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Įjungta"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Išjungta"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Nustatymas išjungtas, nes įrenginys nutildytas"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Skambučiai"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Pranešimai ir signalai"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interaktyvioji technologija"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Vibravimo ir lietimo technologijos naudojimas"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Signalo vibravimas"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Medijos vibravimas"</string>
    <string name="accessibility_keyboard_vibration_title" msgid="7559967730626765441">"Klaviatūros vibravimas"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibravimas skambant telefonui"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibravimas gavus pranešimą"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Lietimo grįžtamasis ryšys"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Naudoti „<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>“"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Atidaryti „<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>“"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"Programa „<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>“ pridėta prie sparčiųjų nustatymų. Perbraukite žemyn, kad bet kuriuo metu įjungtumėte arba išjungtumėte."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Be to, programą „<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>“ galite pridėti prie sparčiųjų nustatymų iš ekrano viršaus"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Spalvų taisymas pridėtas prie sparčiųjų nustatymų. Perbraukite žemyn, kad bet kuriuo metu įjungtumėte arba išjungtumėte."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Be to, spalvų taisymą galite pridėti prie sparčiųjų nustatymų iš ekrano viršaus"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Spalvų inversija pridėta prie sparčiųjų nustatymų. Perbraukite žemyn, kad bet kuriuo metu įjungtumėte arba išjungtumėte."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Be to, spalvų inversiją galite pridėti prie sparčiųjų nustatymų iš ekrano viršaus"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Itin blankus šviesumas pridėtas prie sparčiųjų nustatymų. Perbraukite žemyn, kad bet kuriuo metu įjungtumėte arba išjungtumėte."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Be to, itin blankų šviesumą galite pridėti prie sparčiųjų nustatymų iš ekrano viršaus"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Vienos rankos režimas pridėtas prie sparčiųjų nustatymų. Perbraukite žemyn, kad bet kuriuo metu įjungtumėte arba išjungtumėte."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Be to, vienos rankos režimą galite pridėti prie sparčiųjų nustatymų iš ekrano viršaus"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Šrifto dydis pridėtas prie sparčiųjų nustatymų. Perbraukite žemyn bet kuriuo metu, kad pakeistumėte šrifto dydį."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Atsisakyti"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Naudoti spalvų taisymą"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Spalvų taisymo spartusis klavišas"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Apie spalvų taisymą"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Sužinokite daugiau apie spalvų taisymą"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Apie spalvų inversiją"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Sužinokite daugiau apie spalvų inversiją"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Rodyti subtitrus"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Tik palaikomai programai"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Subtitrų dydis ir stilius"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Teksto dydis: <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Daugiau parinkčių"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Tinkinkite subtitrų dydį ir stilių, kad būtų lengviau skaityti"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Šios subtitrų nuostatos palaikomos ne visose medijos programose"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Pritaikomumo mygtukas"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"2 pirštais perbraukti aukštyn iš apačios"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Laikyti garsumo klavišus"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Triskart paliesti ekraną"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Tęsti"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Klausos įrenginiai"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Galite naudoti klausos aparatus, vidinės ausies implantus ir kitus garso stiprinimo įrenginius su telefonu"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Prijungtų klausos įrenginių nėra"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Pridėti klausos aparatų"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Klausos apar. susiejimas"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Kitame ekrane palieskite klausos aparatus. Kairiosios ausies ir dešiniosios ausies klausos aparatus gali reikėti susieti atskirai.\n\nĮsitikinkite, kad klausos aparatai įjungti ir paruošti susieti."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"„<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“ įrenginys aktyvus"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"„<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“, tik kairiojoje pusėje"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"„<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“, tik dešiniojoje pusėje"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"„<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“, kairiojoje ir dešiniojoje pusėse"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"„<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“ ir dar 1"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Naujo įrenginio susiejimas"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"Apie naujo įrenginio susiejimo funkciją"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Klausos įrenginiai"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Išsaugoti įrenginiai"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Klausos įrenginio valdikliai"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Klausos įrenginio spartusis klavišas"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Klausos aparato suderinamumas"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Pagerinamas suderinamumas su teleritėmis ir sumažinamas nepageidaujamas triukšmas"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Apie klausos įrenginius"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Įsitikinkite, kad klausos įrenginys įjungtas ir paruoštas susieti"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Klausos įrenginio susiejimas"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Pasiekiami klausos įrenginiai"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Nematote savo klausos įrenginio?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Daugiau įrenginių"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Garso koregavimas"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Garsų aprašas"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Klausykitės ekrane rodomų įvykių aprašo palaikomuose filmuose ir serialuose"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"garsų aprašas, garsas, aprašas, sutrikusio regėjimo asmuo,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Spartusis klavišas įjungtas"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Išjungti"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Įjungta"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Išjungta"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Neveikia. Palieskite, kad gautumėte informacijos."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Ši paslauga veikia netinkamai."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Pritaikomumo šaukiniai"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Rodyti sparčiuosiuose nustatymuose"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Raudona, žalia"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Raudona, žalia"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Mėlyna, geltona"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Pilkumo tonas"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Silpna žalia (deuteranomalija)"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Silpna raudona (protanomalija)"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomalija"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Itin blanku"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Padaryti ekraną itin blankų"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Funkcijos „Itin blanku“ spartusis klavišas"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Apie funkciją „Itin blanku“"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Padarykite ekraną blankesnį, kad būtų patogiau skaityti"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensyvumas"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Tamsiau"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Šviesiau"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Palikti įjungtą paleidus įrenginį iš naujo"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Trumpa ({time} sekundė)}one{Trumpa ({time} sekundė)}few{Trumpa ({time} sekundės)}many{Trumpa ({time} sekundės)}other{Trumpa ({time} sekundžių)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Vidutinė ({time} sekundė)}one{Vidutinė ({time} sekundė)}few{Vidutinė ({time} sekundės)}many{Vidutinė ({time} sekundės)}other{Vidutinė ({time} sekundžių)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Ilga ({time} sekundė)}one{Ilga ({time} sekundė)}few{Ilga ({time} sekundės)}many{Ilga ({time} sekundės)}other{Ilga ({time} sekundžių)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} sekundė}one{{time} sekundė}few{{time} sekundės}many{{time} sekundės}other{{time} sekundžių}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Nustatymai"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Įjungta"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Išjungta"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Peržiūra"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standartinės parinktys"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Kalba"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Teksto dydis"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Subtitrų stilius"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Tinkintos parinktys"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Fono spalva"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Fono nepermatomumas"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Antraštės lango spalva"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Antraštės lango nepermatomumas"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Teksto spalva"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Teksto nepermatomumas"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Krašto spalva"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Krašto tipas"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Šriftų grupė"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Subtitrai atrodys taip"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Numatytoji"</string>
    <string name="color_title" msgid="2511586788643787427">"Spalva"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Numatytoji"</string>
    <string name="color_none" msgid="3703632796520710651">"Nėra"</string>
    <string name="color_white" msgid="1896703263492828323">"Balta"</string>
    <string name="color_gray" msgid="8554077329905747877">"Pilka"</string>
    <string name="color_black" msgid="9006830401670410387">"Juoda"</string>
    <string name="color_red" msgid="5210756997426500693">"Raudona"</string>
    <string name="color_green" msgid="4400462091250882271">"Žalia"</string>
    <string name="color_blue" msgid="4997784644979140261">"Mėlyna"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Žalsvai mėlyna"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Geltona"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Purpurinė"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Leisti „<xliff:g id="SERVICE">%1$s</xliff:g>“ valdyti visas įrenginio funkcijas?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"„<xliff:g id="SERVICE">%1$s</xliff:g>“ reikia:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Kadangi programa užstoja leidimo užklausą, nustatymuose negalima patvirtinti jūsų atsakymo."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"„<xliff:g id="SERVICE">%1$s</xliff:g>“ nori valdyti visas šio įrenginio funkcijas. Paslauga gali skaityti ekraną ir veikti specialiųjų poreikių turinčių naudotojų vardu. Šis valdymo lygis nėra tinkamas daugumai programų."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Galimybę valdyti visas funkcijas patariama suteikti programoms, kurios padeda specialiųjų poreikių turintiems asmenims, bet ne daugumai programų."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Ekrano peržiūra ir valdymas"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Naudojant šį ekrano valdiklį galima skaityti visą ekrane rodomą turinį ir rodyti turinį virš kitų programų."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Veiksmų peržiūra ir atlikimas"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Naudojant šią funkciją galima stebėti jūsų sąveiką su programa ar aparatinės įrangos jutikliu ir sąveikauti su programomis jūsų vardu."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Leisti"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Atmesti"</string>
    <string name="accessibility_dialog_button_stop" msgid="7584815613743292151">"Išjungti"</string>
    <string name="accessibility_dialog_button_cancel" msgid="8625997437316659966">"Palikti įjungtą"</string>
    <string name="disable_service_title" msgid="8178020230162342801">"Išjungti „<xliff:g id="SERVICE">%1$s</xliff:g>“?"</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Nėra įdiegta jokių paslaugų"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Nepasirinkta jokia paslauga"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Nepateikta jokių aprašų."</string>
    <string name="settings_button" msgid="2195468788019730377">"Nustatymai"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"jautrumas šviesai, fotofobija, tamsioji tema, migrena, galvos skausmas, skaitymo režimas, naktinis režimas, šviesumo mažinimas, baltas taškas"</string>
    <string name="keywords_accessibility" msgid="8593989878379366798">"regėjimas, klausa, aklasis, kurčias asmuo, motorika, miklumas, pagalbinis, pagalba, paprasta naudoti, paprasta pasiekti, ranka, padėti"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"„Window Magnifier“, mastelio keitimas, didinimas, sutrikusio regėjimo asmuo, padidinti, padaryti didesnį"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Subtitrai, CC, transkripcija realiuoju laiku, neprigirdintis asmuo, klausos sutrikimai, CART, kalba į tekstą, titrai"</string>
    <string name="keywords_live_transcribe" msgid="3226990195174890997"></string>
    <string name="keywords_sound_notifications" msgid="8183107485754075413"></string>
    <string name="keywords_sound_amplifier" msgid="939404835256246663"></string>
    <string name="keywords_display_size" msgid="5286419615221231518">"ekrano dydis, didelis ekranas"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Didelis kontrastas, sutrikusio regėjimo asmuo, pusjuodis šriftas"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"koreguoti spalvą"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"įjungti tamsų ekraną, įjungti šviesų ekraną"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"spalvų kontrastas"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="6811744211216280998">"motorika, pelė, išorinė pelė, pelė ant galvos, prisitaikanti pelė, neįgaliųjų vežimėlis, vairasvirtė"</string>
    <string name="keywords_hearing_aids" msgid="4657889873249157071">"klausos aparatai, neprigirdintis asmuo, klausos praradimas, vidinės ausies implantai, garso stiprinimo įrenginiai, garso apdorojimo priemonės, PSAP"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"neprigirdintis asmuo, klausos sutrikimai, subtitrai, teletaipas, TTY"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="keywords_3_button_navigation" msgid="436361965016404218">"trys mygtukai"</string>
    <string name="keywords_touch_and_hold_delay" msgid="7854640156419599912">"miklumas, motorika, vyresnis, artritas, RSI, priepuolis, tremoras, išsėtinė sklerozė, cerebrinis paralyžius, drebulys, pakartotinis patempimas, ranka"</string>
    <string name="keywords_accessibility_timeout" msgid="8903766864902000346">"delsa, miklumas, vyresnis"</string>
    <string name="print_settings" msgid="8519810615863882491">"Spausdinimas"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Išjungta"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{Įjungta 1 spausdinimo paslauga}one{Įjungta # spausdinimo paslauga}few{Įjungtos # spausdinimo paslaugos}many{Įjungta # spausdinimo paslaugos}other{Įjungta # spausdinimo paslaugų}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 spausdinimo užduotis}one{# spausdinimo užduotis}few{# spausdinimo užduotys}many{# spausdinimo užduoties}other{# spausdinimo užduočių}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Spausdinimo paslaugos"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Nėra įdiegta jokių paslaugų"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Nerasta jokių spausdintuvų"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Nustatymai"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Pridėti spausdintuvų"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Įjungta"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Išjungta"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Pridėti paslaugą"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Pridėti spausdintuvą"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Paieška"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Ieškoma spausdintuvų"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Paslauga neleidžiama"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Spausdinimo užduotys"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Spausdinimo užduotis"</string>
    <string name="print_restart" msgid="4424096106141083945">"Paleisti iš naujo"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Atšaukti"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"Konfigūruojama: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Spausdinama: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Atšaukiama: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Spausdintuvo klaida: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Spausdintuvas užblokavo <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Paieškos laukelis rodomas"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Paieškos laukelis paslėptas"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Daugiau informacijos apie šį spausdintuvą"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Akumuliatorius"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Kas naudojo akumuliatorių"</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"Liko: <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"Liko įkrauti: <xliff:g id="UNTIL_CHARGED">%1$s</xliff:g>"</string>
    <string name="power_usage_detail_screen_time" msgid="6027274749498485283">"Įrenginio naudojimo laikas"</string>
    <string name="power_usage_detail_background_time" msgid="3661437083554322691">"Laikas fone"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Senka akumuliatorius"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Leiskite vykdyti programą fone"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Apriboti veiklą fone?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Jei apribosite programos veiklą fone, ji gali netinkamai veikti"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Negalite apriboti progr., nes ji nenust. optimiz. akum. naud.\n\nJei norite apr. progr., pirmiausia įj. akum. naud. optimiz."</string>
    <string name="manager_battery_usage_category_title" msgid="1493303237531629961">"Akumuliatoriaus energijos vartojimo valdymas"</string>
    <string name="manager_battery_usage_allow_background_usage_title" msgid="6294649996820358852">"Leisti naudoti fone"</string>
    <string name="manager_battery_usage_allow_background_usage_summary" msgid="8021153755201340819">"Įgalinkite, kad gautumėte naujienas realiuoju laiku, arba išjunkite, kad tausotumėte akumuliatoriaus energiją"</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Neapribota"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimizuota"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Apribota"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Leiskite vartoti akumuliatoriaus energiją fone be apribojimų. Gali būti suvartojama daugiau akumuliatoriaus energijos."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimizavimas pagrįstas naudojimo duomenimis. Rekomenduojama daugumai programų."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Apribokite akumuliatoriaus energijos vartojimą fone. Programos gali neveikti, kaip numatyta. Pranešimai gali vėluoti."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Pakeitus, kaip programa vartoja akumuliatoriaus energiją, gali būti paveiktas našumas."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Šiai programai būtina nustatyti šią akumuliatoriaus energijos vartojimo parinktį: <xliff:g id="STATE">%1$s</xliff:g>."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"neapribota"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimizuota"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Sužinokite daugiau apie akumuliatoriaus energijos vartojimo parinktis"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Ekrano naudojimas po paskutinio visiško įkrovimo"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Akum. energ. vart."</string>
    <string name="history_details_title" msgid="8628584613889559355">"Istorijos informacija"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Akumuliatoriaus energijos vartojimas"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Naudojimo per pastar. 24 val. peržiūra"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Žr. akum. lygį nuo paskutinio įkrovimo"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Programos akumuliatoriaus energijos vartojimas"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Išsami naudojimo informacija"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Reguliuoti maitinimo naudojimą"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Įtraukti paketai"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Programos veikia įprastai"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Žemas akumuliatoriaus lygis"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Įjunkite Akumuliatoriaus tausojimo priemonę, kad akumuliatorius veiktų ilgiau"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Akumuliatoriaus veikimo laiko pailginimas"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Įjunkite Akumuliatoriaus tvarkytuvę"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Įjunkite Akumuliatoriaus tausojimo priemonę"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Akumuliatoriaus energija gali išsekti greičiau nei įprasta"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Akumuliatoriaus tausojimo priemonė įjungta"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Sužinokite daugiau apie Akumuliatoriaus tausojimo priemonę"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Kai kurios funkcijos gali būti apribotos"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Vartojama daugiau akumuliatoriaus energijos"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Žr. daugiausia energijos vartojančias programas"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Įkrovimas optimizuotas, siekiant apsaugoti akumuliatorių"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Kad akumuliatorius veiktų ilgiau, įkrovimas optimizuotas"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Sužinokite daugiau apie pristabdyto įkrovimo būseną"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Tęsti įkrovimą"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Įtraukiama daug energijos eikvojanti veikla fone"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Apriboti # programą}one{Apriboti # programą}few{Apriboti # programas}many{Apriboti # programos}other{Apriboti # programų}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{Neseniai apribota {label}}one{Neseniai apribota # programa}few{Neseniai apribotos # programos}many{Neseniai apribota # programos}other{Neseniai apribota # programų}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{Fone veikianti {label} naudoja daug akumuliatoriaus energijos}one{Fone veikianti # programa naudoja daug akumuliatoriaus energijos}few{Fone veikiančios # programos naudoja daug akumuliatoriaus energijos}many{Fone veikiančios # programos naudoja daug akumuliatoriaus energijos}other{Fone veikiančios # programos naudoja daug akumuliatoriaus energijos}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Ši programa negali veikti fone}one{Šios programos negali veikti fone}few{Šios programos negali veikti fone}many{Šios programos negali veikti fone}other{Šios programos negali veikti fone}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Apriboti programą?}one{Apriboti # programą?}few{Apriboti # programas?}many{Apriboti # programos?}other{Apriboti # programų?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Jei norite tausoti akumuliatoriaus energiją, neleiskite „<xliff:g id="APP">%1$s</xliff:g>“ eikvoti akumuliatoriaus energijos fone. Ši programa gali tinkamai neveikti ir pranešimai gali būti atidėti."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Jei norite tausoti akumuliatoriaus energiją, neleiskite šioms programoms eikvoti akumuliatoriaus energijos fone. Ribojamos programos gali tinkamai neveikti ir pranešimai gali būti atidėti.\n\nProgramos:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Jei norite tausoti akumuliatoriaus energiją, neleiskite šioms programoms eikvoti akumuliatoriaus energijos fone. Ribojamos programos gali tinkamai neveikti ir pranešimai gali būti atidėti.\n\nProgramos:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Apriboti"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Pašalinti apribojimą?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Ši programa galės naudoti akumuliatoriaus energiją fone. Akumuliatoriaus energija gali išsekti greičiau nei tikėjotės."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Pašalinti"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Atšaukti"</string>
    <!-- no translation found for battery_tip_charge_to_full_button (9172893341338732733) -->
    <skip />
    <string name="battery_tip_incompatible_charging_title" msgid="1567827436103364999">"Įkrovimo priedo patikra"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Sužinokite daugiau apie nesuderinamą įkrovimą"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Akumuliatoriaus tvarkytuvė"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Automatinis programų tvarkymas"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Kai akumuliatoriaus tvarkytuvė aptinka, kad programos eikvoja akumuliatoriaus energiją, galite apriboti šias programas. Ribojamos programos gali tinkamai neveikti ir pranešimai gali būti atidėti."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Apribotos programos"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Ribojamas # programos akumuliatoriaus energijos vartojimas}one{Ribojamas # programos akumuliatoriaus energijos vartojimas}few{Ribojamas # programų akumuliatoriaus energijos vartojimas}many{Ribojamas # programos akumuliatoriaus energijos vartojimas}other{Ribojamas # programų akumuliatoriaus energijos vartojimas}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Apribota <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Šios programos ribojamos, kad nevartotų akumuliatoriaus energijos veikdamos fone. Jos gali neveikti, kaip numatyta, o pranešimai gali vėluoti."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Akumuliatoriaus tvarkytuvės naudojimas"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Aptikti, kai programos eikvoja akumuliatoriaus energiją"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Aptikimas, kai programos eikvoja akumuliatoriaus energiją"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Aptikimas, kai programos eikvoja akumuliatoriaus energiją"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{Apribota # programa}one{Apribota # programa}few{Apribotos # programos}many{Apribota # programos}other{Apribota # programų}}"</string>
    <string name="battery_header_title_alternate" msgid="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="400958471814422770">"Nuskaitant akumuliatoriaus skaitiklį iškilo problema."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Palieskite, jei norite sužinoti daugiau apie šią klaidą"</string>
    <string name="power_screen" msgid="4596900105850963806">"Ekranas"</string>
    <string name="power_cpu" msgid="1820472721627148746">"Centrinis procesorius"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Žibintuvėlis"</string>
    <string name="power_camera" msgid="4778315081581293923">"Fotoaparatas"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Mobiliojo ryšio tinklas"</string>
    <string name="power_phone" msgid="2768396619208561670">"Balso skambučiai"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Ekrano naudojimas: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> naudoja „<xliff:g id="APP">%2$s</xliff:g>“"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> visos akumuliatoriaus įkrovos"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Naudojimo nuo paskutinio visiško įkrovimo analizė"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Paskutinis visiškas įkrovimas"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Visiškai įkrauti trunka apie"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Likęs akumuliatoriaus veikimo laikas yra apytikslis ir gali pasikeisti atsižvelgiant į naudojimą"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Akumuliatoriaus energijos vartojimas"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Nenaudota nuo paskutinio visiško įkrovimo"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Nenaudota per pastarąsias 24 val."</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"nuo paskutinio visiško įkrovimo"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Sistemos programos"</string>
    <string name="battery_usage_uninstalled_apps" msgid="8170405012552803662">"Pašalintos programos"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Kita"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Liko laiko (numatyta)"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Iki visiško įkrovimo"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Numatyti duomenys gali keistis atsižvelgiant į naudojimą"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Medijos serveris"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Programų optimizavimas"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Įrenginio kaip modemo naudojimas"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Pašalintos programos"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Akumuliator. tausoj. priem."</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Įjungti automatiškai"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Nėra tvarkaraščio"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Pagal jūsų veiksmų seką"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Bus įjungta atsižvelgiant į jūsų veiksmų seką"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Pagal procentinį dydį"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Akumuliatoriaus tausojimo priemonė įjungiama, jei numatoma, kad akumuliatorius išsikraus iki kito įprastai atliekamo įkrovimo"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Bus įjungta pasiekus <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Nustatyti tvarkaraštį"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Pailginti akumuliatoriaus veikimo laiką"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Išjungti įkrovus"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Išjungti pasiekus <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Akumuliatoriaus tausojimo priemonė išjungiama, kai akumuliatorius pasiekia <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Įjungti"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Naudoti Akumuliatoriaus tausojimo priemonę"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Įjungti automatiškai"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Niekada"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"kai akumuliatoriaus įkrovos lygis yra <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Akumuliatoriaus energija procentais"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Rodyti akumuliatoriaus energiją procentais būsenos juostoje"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Akumuliatoriaus lygis po paskutinio visiško įkrovimo"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Akumuliatoriaus įkrovos lygis per pastarąsias 24 val."</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Programų naudojimas po paskutinio visiško įkrovimo"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Programos naudojimas per pastarąsias 24 val."</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Sistemos naudojimas po paskutinio visiško įkrovimo"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Sistemos naudojimas per pastarąsias 24 val."</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Sistemos naudojimas: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Programos naudojimas: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Sistemos naudojimas po paskutinio visiško įkrovimo iki <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Programų naudojimas po paskutinio visiško įkrovimo iki <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Iš viso: mažiau nei minutė"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Fonas: trumpiau nei minutė"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Įrenginio naudojimo laikas: mažiau nei minutė"</string>
    <string name="power_usage_time_less_than_one_minute" msgid="8407404329381010144">"Mažiau nei minutė"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Iš viso: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Fonas: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Įrenginio naudojimo laikas: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Akumuliatoriaus energijos vartojimo duomenys bus pasiekiami po kelių valandų visiškai įkrovus įrenginį"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"dabar"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g>–<xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g> <xliff:g id="HOUR">%2$s</xliff:g>⁠"</string>
    <string name="battery_usage_time_info_and_battery_level" msgid="6732629268310936155">"<xliff:g id="TIME_INFO">%1$s</xliff:g> <xliff:g id="BATTERY_LEVEL">%2$s</xliff:g>⁠"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Akumuliatoriaus energijos vartojimo diagrama"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Akumuliatoriaus energijos vartojimo kas dieną diagrama"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Akumuliatoriaus energijos vartojimo kas valandą diagrama"</string>
    <string name="battery_level_percentage" msgid="1433178290838842146">"Akumuliatoriaus įkrovos lygis procentais nuo <xliff:g id="START_PERCENTAGE">%1$s</xliff:g> iki <xliff:g id="END_PERCENTAGE">%2$s</xliff:g>"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Akumuliatoriaus naudojimo laikas nuo pastarojo visiško įkrovimo"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Akumuliatoriaus naudojimas su pasirinkta <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Įrenginio naudojimo laikas nuo paskutinio visiško įkrovimo"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Įrenginio naudojimo laikas: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Peržiūrėti pagal programas"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Peržiūrėti pagal sistemas"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_cycle_count_footer" msgid="3642121059800373545">"Dėl kokybės patikros prieš siunčiant ciklų skaičius gali būti ne nulis pirmą kartą naudojant"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Procesų statistika"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Entuziastų pateikta statistika apie vykstančius procesus"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Naudojama atmintis"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"Per paskutines <xliff:g id="TIMEDURATION">%3$s</xliff:g> išnaudota <xliff:g id="USEDRAM">%1$s</xliff:g> iš <xliff:g id="TOTALRAM">%2$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"Per <xliff:g id="TIMEDURATION">%2$s</xliff:g> išnaudota <xliff:g id="PERCENT">%1$s</xliff:g> RAM"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Fonas"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Priekinis planas"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Išsaugota talpykloje"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"„Android“ OS"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Savasis"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Branduolys"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Talpyklos"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"RAM naudojimas"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"RAM naudojimas (fonas)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Rodymo laikas"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Procesai"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Paslaugos"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Trukmė"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Išsami atminties informacija"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 val."</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 val."</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 val."</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 d."</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Rodyti sistemą"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Slėpti sistemą"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Rodyti procentinius dydžius"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Naudoti USS"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Statistikos tipas"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Fonas"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Priekinis planas"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Išsaugota talpykloje"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Balso įvestis ir išvestis"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Balso įvesties ir išvesties nustatymai"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Paieška balsu"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"„Android“ klaviatūra"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Įvesties balsu nustatymai"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Įvestis balsu"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Įvesties balsu paslaugos"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Visas aktyvinamasis žodis ir sąveika"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Paprasta kalbos keitimo į tekstą funkcija"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Ši įvesties balsu paslauga galės visada stebėti balsu vykdomus veiksmus ir valdyti balsu įgalintas programas jūsų vardu. Ji teikiama iš programos <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Įgalinti šios paslaugos naudojimą?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Atpažinimo įrenginyje nustatymai"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Atpažinimas įrenginyje"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Kalbos atpažinimas įrenginyje"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Pageidaujamas variklis"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Variklio nustatymai"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Kalbėjimo greitis ir tonas"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Variklis"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Balsai"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Kalba, kuria kalbama"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Balsų diegimas"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Eikite į programą „<xliff:g id="TTS_APP_NAME">%s</xliff:g>“, kad įdiegtumėte balsus"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Atidaryti programą"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Atšaukti"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Nustatyti iš naujo"</string>
    <string name="tts_play" msgid="2945513377250757221">"Paleisti"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Nesaugu"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"Nesaugu: <xliff:g id="VPN_COUNT">%d</xliff:g>"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"Nesaugu: <xliff:g id="VPN_COUNT">%d</xliff:g>"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Adaptyvusis ryšių tvarkymas"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Automatiškai tvarkant tinklo ryšius pailgėja akumuliatoriaus veikimo laikas ir pagerėja įrenginio našumas"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Įjungta"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Išjungta"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Prisitaikančio ryšio naudojimas"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Prisijungimo duomenų saugykla"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Įdiegti sertifikatą"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Valyti prisijungimo duomenis"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Pašalinti visus sertifikatus"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Patikimi prisijungimo duomenys"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Rodyti patikimus CA sertifikatus"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Naudotojo prisijungimo duom."</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Peržiūrėkite ir keiskite išsaugotus prisijungimo duomenis"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Išplėstiniai"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Prisijungimo duomenys nepasiekiami šiam naudotojui"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Įdiegta VPN ir programoms"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Įdiegta „Wi-Fi“"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Įdiegta „Wi-Fi“ (naudojama)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Pašalinti visą turinį?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Kredencialų atmintinė ištrinta."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Nepavyko ištr. kreden. atmint."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Progr., gal. pasiekti duom."</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA sertifikatas"</string>
    <string name="user_certificate" msgid="6897024598058566466">"VPN ir progr. naud. sertifik."</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"„Wi‑Fi“ sertifikatas"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Jūsų duomenys nebus privatūs"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Šifruojant CA sertifikatus naudoja svetainės, programos ir VPN. CA sertifikatus įdiekite tik iš patikimų organizacijų. \n\nJei įdiegsite CA sertifikatą, jo savininkas galės pasiekti jūsų duomenis (net jei jie šifruoti), pvz., slaptažodžius ar išsamią kredito kortelių informaciją, svetainėse, kuriose lankotės, arba programose, kurias naudojate."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Neįdiegti"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Vis tiek įdiegti"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Sertifikatas neįdiegtas"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Leisti "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" įdiegti sertifikatus šiame įrenginyje?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Šiais sertifikatais bus patvirtinama jūsų tapatybė bendrinant įrenginio unikalų ID su toliau nurodytais URL ir programomis"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Neleisti"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Leisti"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Rodyti daugiau"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Sertifikatų tvarkymo programa"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Nėra"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Sertifikatais bus patvirtinama jūsų tapatybė, kai naudosite toliau nurodytus URL ir programas"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Pašalinti sertifikatus"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Pašalinti programą"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Pašalinti šią programą?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Ši programa netvarkys sertifikatų, bet liks įrenginyje. Bet kokie programos įdiegti sertifikatai bus pašalinti."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}one{# URL}few{# URL}many{# URL}other{# URL}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Kritinės padėties numerio rinkimo signalas"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Nustatyti elgesį, kai skambinama pagalbos numeriu"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Atsarginė kopija"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Kurti atsarginę kopiją ir atkurti"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Asmeniniai duomenys"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Kurti atsarginę duomenų kopiją"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"„Google“ serveriuose kurti atsargines programos duomenų, „Wi-Fi“ slaptažodžių ir kitų nustatymų kopijas"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Atsarg. kopijos paskyra"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Atsarginės paskyros tvarkymas"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Įtraukti programos duomenis"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automatinis atkūrimas"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Iš naujo įdiegdami programą atkurkite nustatymus ir duomenis, kurių atsarginės kopijos buvo sukurtos"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Atsarginė paslauga neaktyvi"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Šiuo metu jokioje paskyroje nesaugomi atsarginės kopijos duomenys"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"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="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Nebekurti įrenginio duomenų (pvz., „Wi-Fi“ slaptažodžių ir skambučių istorijos) ir programų duomenų (pvz., programų saugomų nustatymų ir failų) atsarginių kopijų ir ištrinti visas kopijas iš nuotolinių serverių?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Automatiškai nuotoliniu būdu sukurkite atsarginę įrenginio duomenų (pvz., „Wi-Fi“ slaptažodžių ir skambučių istorijos) ir programų duomenų (pvz., programų nustatymų ir išsaugotų failų) kopiją.\n\nKai įjungiate automatinę atsarginę kopiją, įrenginio ir programų duomenys periodiškai išsaugomi nuotoliniu būdu. Programų duomenys gali būti bet kurie programų išsaugoti duomenys (atsižvelgiant į kūrėjo nustatymus), įskaitant duomenis, kurie gali būti neskelbtini, pvz., kontaktai, pranešimai ir nuotraukos."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Įrenginio administratoriaus nustatymai"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Įrenginio administravimo programa"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Išaktyvinti šią įrenginio administravimo programą"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Pašalinti programą"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Išaktyvinti ir pašalinti"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Įrenginio administravimo programos"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Nėra pasiekiamų įrenginio administravimo programų"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Nėra jokių galimų „trust agents“"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Suaktyvinti įrenginio administravimo programą?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Suaktyvinti šio įrenginio administravimo programą"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Įrenginio administratorius"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Suaktyvinus šią administravimo programą programai <xliff:g id="APP_NAME">%1$s</xliff:g> bus leidžiama vykdyti toliau nurodytas operacijas."</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ tvarkys ir stebės šį įrenginį."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Ši administravimo programa yra aktyvi ir programai <xliff:g id="APP_NAME">%1$s</xliff:g> leidžiama vykdyti toliau nurodytas operacijas."</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Suaktyvinti profilio valdytoją?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Leisti atlikti priežiūrą?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Jei tęsite, jūsų naudotoją tvarkys administratorius, kuris be jūsų asmeninių duomenų galės išsaugoti susijusius duomenis.\n\nAdministratorius gali stebėti ir tvarkyti nustatymus, prieigą, programas ir su šiuo naudotoju susijusius duomenis, įskaitant tinklo veiklą ir įrenginio vietovės informaciją."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Kitas parinktis išjungė jūsų administratorius."</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Sužinokite daugiau"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Pranešimų žurnalas"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Pranešimų istorija"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Pastar. %d val."</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Nustatyta snausti"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Neseniai atsisakyta"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# pranešimas}one{# pranešimas}few{# pranešimai}many{# pranešimo}other{# pranešimų}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Skambinimo tonas ir vibracija"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Išsami tinklo inf."</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sinchronizavimas įgalintas"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sinchronizavimas neleidžiamas"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Sinchronizuojama dabar"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Sinchronizavimo klaida."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Įvyko sinchronizavimo klaida"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sinchronizavimas aktyvus"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sinchronizavimas"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Šiuo metu iškilo sinchronizavimo problemų. Greitai jis vėl vyks."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Pridėti paskyrą"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Darbo profilis dar nepasiekiamas"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Darbo programos"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Pašalinti darbo profilį"</string>
    <string name="background_data" msgid="321903213000101158">"Foniniai duomenys"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Programos gali bet kada sinchron., siųsti ir gauti duomenis"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Neleisti fon. duom.?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"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_enabled" msgid="5794103781356455043">"Sinchroniz. įjungtas"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sinchron. IŠJUNGTAS"</string>
    <string name="sync_error" msgid="846923369794727644">"Sinchronizav. klaida"</string>
    <string name="last_synced" msgid="1527008461298110443">"Pastarąjį kartą sinchronizuota <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sinchronizuojama dabar…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Atsarginės kopijos kūrimo nustatymai"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Kurti atsarginę nustatymų kopiją"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sinchronizuoti dabar"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Atšaukti sinchronizavimą"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Palieskite, jei norite dabar sinchronizuoti<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Kalendorius"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontaktai"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Programos sinchronizavimo nustatymai"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Duomenys ir sinchronizavimas"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Keisti slaptažodį"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Paskyros nustatymai"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Pašalinti paskyrą"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Pridėti paskyrą"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Pašalinti paskyrą?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Administratorius neleidžia atlikti šio pakeitimo"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Negalima sinchronizuoti neautomatiškai"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Šiuo metu šio elemento sinchronizavimas neleidžiamas. Jei norite pakeisti šį nustatymą, laikinai įjunkite foninius duomenis ir automatinį sinchronizavimą."</string>
    <string name="delete" msgid="8330605554706263775">"Ištrinti"</string>
    <string name="select_all" msgid="7898929601615536401">"Pasirinkti viską"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Duomenų naudojimas"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mob. r. duom. ir „Wi‑Fi“"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Autom. asmen. duom. sinchron."</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Autom. darbo duom. sinchron."</string>
    <string name="account_settings_menu_auto_sync_private" msgid="2315144351530596228">"Aut. privačių duom. sinchron."</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Keisti ciklą…"</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Mėnesio diena, kai iš naujo nustatomas naudojimo ciklas:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Šiuo laikotarpiu jokios program. nenaudojo duom."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Priekinis planas"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Fonas"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"ribotas"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Išjungti mobiliojo ryšio duomenis?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Nustatyti mobiliųjų duomenų apribojimą"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Nustatyti 4G duomenų apribojimą"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Nustatyti 2G–3G duomenų apribojimą"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Nust. „Wi-Fi“ duom. aprib."</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Eternetas"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobilieji"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G–3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Mobilusis"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Nėra"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobilieji duomenys"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"2G–3G duomenys"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"4G duomenys"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Tarptinklinis ryšys"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Priekinis planas:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Fonas:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Programos nustatymai"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Foniniai duomenys"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Įgalinti mobiliojo ryšio duomenų naudojimą fone"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Kad aprib. šios progr. fon. duom., pirm. nustat. mob. duom. apr."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Apriboti foninius duomenis?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Dėl šios funkcijos, kai pasiekiami tik mobiliojo ryšio 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="8599940395497268584">"Foninius duomenis galima apriboti tik nustačius mobiliojo ryšio duomenų apribojimą."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Įjungti autom. sinchronizavimą?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Išjungti autom. sinchronizavimą?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Tai atlikus bus saikingai naudojami duomenys ir akumuliatoriaus energija, tačiau, jei norėsite surinkti naujausią informaciją, turėsite sinchronizuoti kiekvieną paskyrą neautomatiškai. Be to, negausite pranešimų, kai atsiras naujinių."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Naudojimo ciklo nustatymo iš naujo data"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Kiekvieno mėnesio diena:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Nustatyti"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Nustatyti duomenų naudojimo įspėjimą"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Nustatyti duomenų naudojimo apribojimą"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Duomenų naudojimo ribojimas"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="18">"<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="6947019190890086284"><font size="18">"<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="9065885396147675694">"Pašalintos programos"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Pašalintos programos ir naudotojai"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Tinklo naudojimas"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Matuojamas"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Pavadinimas"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Tipas"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Serverio adresas"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"„IPSec“ identifikatorius"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"„IPSec“ iš anksto bendrinamas raktas"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"„IPSec“ naudotojo sertifikatas"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"„IPSec“ CA sertifikatas"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"„IPSec“ serverio sertifikatas"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Rodyti išplėstines parinktis"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Naudotojo vardas"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Slaptažodis"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Išsaugoti paskyros informaciją"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(nenaudojama)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(nepatvirtinti serverio)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(gauta iš serverio)"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Pagal įvestą informaciją nepalaikomas visada įjungtas VPN"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Atšaukti"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Atsisakyti"</string>
    <string name="vpn_save" msgid="683868204634860888">"Išsaugoti"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Prisijungti"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Pakeisti"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Redaguoti VPN profilį"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Pamiršti"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Prisijungti prie <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Atsijungti nuo šio VPN?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Atsijungti"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Versija"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Pamiršti VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Pakeisti esamą VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Nustatyti visada įjungtą VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Įjungę šį nustatymą, neturėsite interneto ryšio, kol VPN nebus sėkmingai prijungtas"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Esamas VPN bus pakeistas ir neturėsite interneto ryšio, kol VPN nebus sėkmingai prijungtas"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Jau esate prisijungę prie visada įjungto VPN. Jei prisijungsite prie kito VPN, esamas VPN bus pakeistas ir visada įjungto VPN režimas bus išjungtas."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Jau esate prisijungę prie VPN. Jei prisijungsite prie kito VPN, esamas VPN bus pakeistas."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Įjungti"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"Nepavyko prisijungti prie „<xliff:g id="VPN_NAME">%1$s</xliff:g>“"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Ši programa nepalaiko visada įjungto VPN"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Pridėti VPN profilį"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Redaguoti profilį"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Ištrinti profilį"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Visada įjungtas VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Nepridėta jokių VPN"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Nustatyti, kad VPN būtų visada įjungtas"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Nepalaikoma šioje programoje"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Visada įjungta"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Nesaugu"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Blokuoti ryšius be VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Būtinas VPN ryšys?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Nesaugu. Atnaujinkite į IKEv2 VPN"</string>
    <string name="vpn_start_unsupported" msgid="7139925503292269904">"Nepavyko paleisti nepalaikomo VPN."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"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="455915403560910517">"Joks"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Norint, kad VPN būtų visada įjungtas, reikalingas serverio ir DNS IP adresas."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Šiuo metu nėra tinklo ryšio. Bandykite dar kartą vėliau."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Atsijungta nuo VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Nėra"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Nėra sertifikato. Pabandykite redaguoti profilį."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Sistema"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Naudotojas"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Išjungti"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Įgalinti"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Pašalinti"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Pasitikėti"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Įgalinti sistemos CA sertifikatą?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Neleisti sistemos CA sertifikato?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Visam laikui pašalinti naudotojo CA sertifikatą?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Naudojama"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Šiame įraše yra toliau nurodyti dalykai"</string>
    <string name="one_userkey" msgid="6363426728683951234">"Vienas naudotojo raktas"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"Vienas naudotojo sertifikatas"</string>
    <string name="one_cacrt" msgid="982242103604501559">"Vienas CA sertifikatas"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA sertifikatai"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Išsami prisijungimo duomenų informacija"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Pašalinti prisijungimo duomenys: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Nenustatyti jokie naudotojo prisijungimo duomenys"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Rašybos tikrinimas"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Darbo teksto rašybos tikrinimas"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Čia įveskite visą dabartinį atsarginės kopijos slaptažodį"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Čia įveskite naują visų atsarginių kopijų slaptažodį"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Čia iš naujo įveskite visą atsarginės kopijos slaptažodį"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Nustatyti atsarginės kopijos slaptažodį"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Atšaukti"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Papildomi sistemos naujiniai"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Tinklas gali būti stebimas"</string>
    <string name="done_button" msgid="6269449526248267">"Atlikta"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Pasitikėti sertifikatu arba jį pašalinti}one{Pasitikėti sertifikatais arba juos pašalinti}few{Pasitikėti sertifikatais arba juos pašalinti}many{Pasitikėti sertifikatais arba juos pašalinti}other{Pasitikėti sertifikatais arba juos pašalinti}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} jūsų įrenginyje įdiegė sertifikavimo institucijos sertifikatą, kuris gali leisti stebėti jūsų įrenginio tinklo veiklą, įskaitant el. laiškus, programas ir saugias svetaines.\n\nJei reikia daugiau informacijos apie šį sertifikatą, susisiekite su savo administratoriumi.}one{{orgName} jūsų įrenginyje įdiegė sertifikavimo institucijos sertifikatus, kurie gali leisti stebėti jūsų įrenginio tinklo veiklą, įskaitant el. laiškus, programas ir saugias svetaines.\n\nJei reikia daugiau informacijos apie šiuos sertifikatus, susisiekite su savo administratoriumi.}few{{orgName} jūsų įrenginyje įdiegė sertifikavimo institucijos sertifikatus, kurie gali leisti stebėti jūsų įrenginio tinklo veiklą, įskaitant el. laiškus, programas ir saugias svetaines.\n\nJei reikia daugiau informacijos apie šiuos sertifikatus, susisiekite su savo administratoriumi.}many{{orgName} jūsų įrenginyje įdiegė sertifikavimo institucijos sertifikatus, kurie gali leisti stebėti jūsų įrenginio tinklo veiklą, įskaitant el. laiškus, programas ir saugias svetaines.\n\nJei reikia daugiau informacijos apie šiuos sertifikatus, susisiekite su savo administratoriumi.}other{{orgName} jūsų įrenginyje įdiegė sertifikavimo institucijos sertifikatus, kurie gali leisti stebėti jūsų įrenginio tinklo veiklą, įskaitant el. laiškus, programas ir saugias svetaines.\n\nJei reikia daugiau informacijos apie šiuos sertifikatus, susisiekite su savo administratoriumi.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} įdiegė jūsų darbo profiliui skirtą sertifikavimo institucijos sertifikatą, kuris gali leisti stebėti jūsų darbo tinklo veiklą, įskaitant el. laiškus, programas ir saugias svetaines.\n\nJei reikia daugiau informacijos apie šį sertifikatą, susisiekite su savo administratoriumi.}one{{orgName} įdiegė jūsų darbo profiliui skirtus sertifikavimo institucijos sertifikatus, kurie gali leisti stebėti jūsų darbo tinklo veiklą, įskaitant el. laiškus, programas ir saugias svetaines.\n\nJei reikia daugiau informacijos apie šiuos sertifikatus, susisiekite su savo administratoriumi.}few{{orgName} įdiegė jūsų darbo profiliui skirtus sertifikavimo institucijos sertifikatus, kurie gali leisti stebėti jūsų darbo tinklo veiklą, įskaitant el. laiškus, programas ir saugias svetaines.\n\nJei reikia daugiau informacijos apie šiuos sertifikatus, susisiekite su savo administratoriumi.}many{{orgName} įdiegė jūsų darbo profiliui skirtus sertifikavimo institucijos sertifikatus, kurie gali leisti stebėti jūsų darbo tinklo veiklą, įskaitant el. laiškus, programas ir saugias svetaines.\n\nJei reikia daugiau informacijos apie šiuos sertifikatus, susisiekite su savo administratoriumi.}other{{orgName} įdiegė jūsų darbo profiliui skirtus sertifikavimo institucijos sertifikatus, kurie gali leisti stebėti jūsų darbo tinklo veiklą, įskaitant el. laiškus, programas ir saugias svetaines.\n\nJei reikia daugiau informacijos apie šiuos sertifikatus, susisiekite su savo administratoriumi.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"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="2044927302268394991">"{count,plural, =1{Tikrinti sertifikatą}one{Tikrinti sertifikatus}few{Tikrinti sertifikatus}many{Tikrinti sertifikatus}other{Tikrinti sertifikatus}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Keli naudotojai"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Naudotojai ir profiliai"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Pridėti naudotoją ar profilį"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Ribotas profilis"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Nenustatyta"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Nenustatytas – ribotas profilis"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Nenustatytas – darbo profilis"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administratorius"</string>
    <string name="user_you" msgid="3070562015202859996">"Jūs (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Negalite pridėti daugiau naudotojų. Pašalinkite naudotoją, kad galėtumėte pridėti naują."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Apribotuose profiliuose negalima pridėti paskyrų"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Ištrinti <xliff:g id="USER_NAME">%1$s</xliff:g> iš šio įr."</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Užrakinimo ekrano nustatymai"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Pridėti naudotojų iš užrakinimo ekrano"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Perjungti į naud. administr., kai prij. prie doko"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Ištrinti save?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Ištrinti šį naudotoją?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Pašalinti šį profilį?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Pašalinti darbo profilį?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Visos programos ir duomenys bus ištrinti."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Jei tęsite, visos šio profilio programos ir duomenys bus ištrinti."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Visos programos ir duomenys bus ištrinti."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Pridedamas naujas naudotojas…"</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Ištrinti naudotoją"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Ištrinti"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Bus ištrintos visos šios sesijos programos ir duomenys."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Pašalinti"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Svečias (jūs)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Naudotojai"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Kiti naudotojai"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Ištrinti svečio veiklą"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Išeinant iš svečio režimo ištrinti visas svečio programas ir duomenis"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Ištrinti svečio veiklą?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Šios svečio sesijos programos ir duomenys bus ištrinti dabar, o visa būsima svečio veikla bus ištrinta kiekvieną kartą, kai išeisite iš svečio režimo"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"ištrinti, svečias, veikla, pašalinti, duomenys, lankytojas, trynimas"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Leidimas svečiui skambinti telefonu"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Skambučių istorija bus bendrinama su naudotoju svečiu"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Įjungti telefono skambučius ir SMS"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Nustatyti šį naudotoją kaip administratorių"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Naudotojo ištrynimas"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Įjungti telefono skambučius ir SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Skambučių ir SMS istorija bus bendrinama su šiuo naudotoju."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Pašalinti administratoriaus privilegijas?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Jei pašalinsite šio naudotojo administratoriaus privilegijas, jūs ar kitas administratorius galės jas vėl suteikti vėliau."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Kritinės padėties informacija"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"<xliff:g id="USER_NAME">%1$s</xliff:g> informacija ir kontaktai"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Atidaryti „<xliff:g id="APP_NAME">%1$s</xliff:g>“"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Leisti programas ir turinį"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Programos su apribojimais"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Išplėsti programos nustatymus"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Pasirinkite programas, kurias norite įdiegti"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Įdiegti pasiekiamas programas"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Nekontaktiniai mokėjimai"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Numatytoji mokėjimų programa"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Norėdami sumokėti mokėjimų programa, palaikykite įrenginio užpakalinę dalį prie mokėjimo terminalo"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Sužinokite daugiau"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Nust. darbo progr. kaip numat. mok. progr.?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Jei norite sumokėti mokėjimų programa:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"darbo profilis turi būti įjungtas."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"turėsite įvesti darbo PIN kodą, atrakinimo piešinį ar slaptažodį, jei turite."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Kaip tai veikia"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Mokėti naudojant telefoną parduotuvėse"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Numatytoji mokėjimo programa"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Nenustatyta"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"„<xliff:g id="APP">%1$s</xliff:g>“ – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="6127665705799658860">"Naudoti numatytąją mokėjimų programą"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Naudoti numatytąją mokėjimų programą"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Visada"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Išskyrus atvejus, kai kita mokėjimo programa atid."</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Nekontaktiniame terminale galima mokėti naudojant:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Mokėjimas terminale"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Nustatykite mokėjimo programą. Tada tiesiog palaikykite užpakalinę telefono dalį prie bet kokios terminalo su nekontaktinio mokėjimo simboliu."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Supratau"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Daugiau…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Nustatyti numatytąją mokėjimo programą"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Atnaujinti numatytąją mokėjimo programą"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Nekontaktiniame terminale galima mokėti naudojant „<xliff:g id="APP">%1$s</xliff:g>“"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Nekontaktiniame terminale galima mokėti naudojant „<xliff:g id="APP_0">%1$s</xliff:g>“.\n\nTai pakeičia „<xliff:g id="APP_1">%2$s</xliff:g>“ kaip numatytąją mokėjimo programą."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Nustatyti numatytuosius nustatymus"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Atnaujinti"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Darbo programos"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Apribojimai"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Pašalinti apribojimus"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Keisti PIN kodą"</string>
    <string name="help_label" msgid="2896538416436125883">"Pagalba ir atsiliep."</string>
    <string name="user_account_title" msgid="6389636876210834864">"Turiniui skirta paskyra"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"Nuotraukos ID"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Didelė grėsmė"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Gaukite įspėjimus apie didelę grėsmę gyvybei ir nuosavybei."</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Rimta grėsmė"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Gaukite įspėjimus apie rimtą grėsmę gyvybei ir nuosavybei"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"AMBER įspėjimai"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Gaukite biuletenių apie vaikų grobimus"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Kartoti"</string>
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Belaidžiu ryšiu siunčiami kritinės pad. įspėjimai"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Tinklo operatoriai"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Prieigos taškų pavadinimai"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Išplėstinės skambinimo parinktys"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"4G skambinimas"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Naudoti LTE paslaugas balso skambučiams tobulinti (rekomenduojama)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Naudoti 4G paslaugas balso skambučiams tobulinti (rekomenduojama)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Naudoti 5G balso skambučiams"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Siųsti kontaktus operatoriui"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Siųskite kontaktų telefono numerius, kad būtų teikiamos patobulintos funkcijos"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Siųsti kontaktus operatoriui „<xliff:g id="CARRIER">%1$s</xliff:g>“?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Siųsti kontaktus operatoriui?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Jūsų kontaktų telefono numeriai bus periodiškai siunčiami operatoriui „<xliff:g id="CARRIER">%1$s</xliff:g>“.<xliff:g id="EMPTY_LINE">

</xliff:g>Ši informacija identifikuoja, ar kontaktai gali naudoti konkrečias funkcijas, pvz., vaizdo skambučius ar kai kurias susirašinėjimo funkcijas."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Jūsų kontaktų telefono numeriai bus periodiškai siunčiami operatoriui.<xliff:g id="EMPTY_LINE">

</xliff:g>Ši informacija identifikuoja, ar kontaktai gali naudoti konkrečias funkcijas, pvz., vaizdo skambučius ar kai kurias susirašinėjimo funkcijas."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Pageidaujamas tinklo tipas"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (rekomenduojama)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"MMS pranešimai"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Siųsti ir gauti, kai mobiliojo ryšio duomenys išjungti"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Automatinis mobiliojo ryšio duomenų perjungimas"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Naudoti šį tinklą, kai jis bus geriau pasiekiamas"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Darbo SIM"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Prieiga prie programų ir turinio"</string>
    <string name="user_rename" msgid="8735940847878484249">"PERVARDYTI"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Nustatykite programos apribojimus"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Kontroliuoja „<xliff:g id="APP">%1$s</xliff:g>“"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Ši programa gali pasiekti jūsų paskyras"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Ši programa gali pasiekti jūsų paskyras. Valdo „<xliff:g id="APP">%1$s</xliff:g>“"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"„Wi‑Fi“ ir mobilusis ryšys"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Leisti keisti „Wi‑Fi“ ir mobiliojo ryšio nustatymus"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Leisti keisti „Bluetooth“ susiejimą ir nustatymus"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Vietovė"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Leisti programoms naudoti vietovės informaciją"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Atgal"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Kitas"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formatuoti kitu būdu"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"SIM kortelės"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobiliojo ryšio duomenys nepasiekiami"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Palieskite, kad pasirinktumėte duomenų SIM"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Visada naudoti tai skambučiams"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Pasirinkite SIM kort. mob. r. duomenims"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Pasirinkite SIM arba SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Perjungiama duomenų SIM kortelė. Tai gali užtrukti iki minutės…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Naudoti „<xliff:g id="NEW_SIM">%1$s</xliff:g>“ mobiliojo ryšio duomenims?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Jei perjungsite į „<xliff:g id="NEW_SIM">%1$s</xliff:g>“, „<xliff:g id="OLD_SIM">%2$s</xliff:g>“ paslaugos nebebus naudojamos mobiliojo ryšio duomenims."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Naudoti „<xliff:g id="NEW_SIM">%1$s</xliff:g>“"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Skambinkite naudodami…"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Įveskite SIM kortelės pavadinimą"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"SIM lizdas %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Oranžinė"</string>
    <string name="color_purple" msgid="6603701972079904843">"Purpurinė"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"SIM būsena"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"SIM būsena (%1$d SIM lizdas)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> ASU"</string>
    <string name="sim_notification_title" msgid="6839556577405929262">"Jūsų SIM kortelė pakeista"</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Palieskite, kad nustatytumėte"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Klausti kaskart"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Būtina pasirinkti"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"SIM pasirinkimas"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Nustatymai"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Tinklas ir internetas"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobiliojo ryšio tinklas, „Wi‑Fi“, viešosios interneto prieigos taškas"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"„Wi‑Fi“, viešosios interneto prieigos taškas"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Prijungti įrenginiai"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"„Bluetooth“, susiejimas"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"„Bluetooth“, vairavimo režimas, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"„Bluetooth“, vairavimo režimas"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"„Bluetooth“, ALR"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"„Bluetooth“, „Android Auto“, vairavimo režimas, ALR"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"„Bluetooth“, „Android Auto“, vairavimo režimas"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"„Bluetooth“, „Android Auto“, ALR"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"„Bluetooth“, „Android Auto“"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Nepasiekiama, nes NFC išjungtas"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Jei norite naudoti, pirmiausia įdiekite mokėjimo programą"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Pastarosios programos, numatytosios programos"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Prieiga prie pranešimų negalima darbo profilio programoms."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Slaptažodžiai ir paskyros"</string>
    <string name="account_dashboard_default_summary" msgid="7976899924144356939">"Prisijungimo ir automatinio pildymo pasiūlymai"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Numatytosios programos"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Nukopijuotos programos"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Sukurkite antrą programos atvejį, kad galėtumėte naudoti dvi paskyras vienu metu."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Programos, kurias galima kopijuoti."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"Nukopijuota: <xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g>; galima kopijuoti: <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g>"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Visų programų kopijų ištrynimas"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Nepavyko ištrinti visų programų kopijų"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Kuriama…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Nukopijuota"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Kuriamas „<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>“ klonas"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Sukurtas „<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>“ klonas"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Kalbos, gestai, laikas, atsarginė kopija"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"Sistemos kalbos, programos kalbos, tinkamumo nustatymai pagal regioną, kalba"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, tinklo ryšys, internetas, belaidis ryšys, duomenys, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"„Wi‑Fi“ pranešimas, „Wi‑Fi“ pranešimas"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"duomenų naudojimas"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Naudoti 24 val. formatą"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Atidaryti naudojant"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Programos"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"laiko juosta"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Pokalbio antraštė, sistema, įspėjimas, langas, dialogo langas, ekranas, virš kitų programų, piešti"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Žibintuvėlis, šviesa, prožektorius"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, perjungimas, valdymas"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobilusis, mobiliojo ryšio operatorius, belaidis, duomenys, 4G, 3G, 2G, LTE"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"„Wi-Fi“, skambinti, skambinama"</string>
    <string name="keywords_display" msgid="874738809280751745">"ekranas, jutiklinis ekranas"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"pritemdyti ekraną, jutiklinis ekranas, akumuliatorius, ryškus"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"pritemdyti ekraną, naktis, atspalvis, naktinis režimas, ryškumas, ekrano spalva, spalva, spalvos"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"fonas, suasmeninti, tinkinti ekraną"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"teksto dydis"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projektavimas, perduoti, ekrano atspindėjimas, ekrano bendrinimas, ekrano vaizdo bendrinimas, bendrinamas ekranas, ekrano perdavimas"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"vieta, diskas, standusis diskas, įrenginio naudojimas"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"energijos eikvojimas, įkrauti"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"akumuliatoriaus energijos vartojimo peržiūra, akumuliatoriaus energijos vartojimas, energijos vartojimas"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"akumuliatoriaus tausojimo priemonė, energijos tausojimo priemonė, tausojimo priemonė"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"prisitaikančio akumuliatoriaus nuostatos, prisitaikantis akumuliatorius"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"rašyba, žodynas, rašybos tikrinimas, automatinis taisymas"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"atpažinimo priemonė, įvestis, kalba, kalbėti, laisvų rankų režimas, atpažinimas, įžeidžiantis, žodis, garsas, istorija, „Bluetooth“ ausinės"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"greitis, kalba, numatytoji, kalbėti, kalbėjimas, tekstas į kalbą, pritaikymas neįgaliesiems, ekrano skaitytuvas, aklas"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"laikrodis, kariuomenė"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"nustatyti iš naujo, atkurti, gamykliniai duomenys"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"naikinti, ištrinti, atkurti, išvalyti, pašalinti, atkurti gamyklinius nustatymus"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"spausdintuvas"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"garsiakalbio pyptelėjimas, garsiakalbis, garsumas, nutildyti, tyla, garso įrašas, muzika, juntamas grįžtamasis ryšys, vibratorius, vibruoti"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"netrukdyti, pertraukti, pertraukimas, pertrauka"</string>
    <string name="keywords_app" msgid="7983814237980258061">"Laisvosios prieigos atmintis"</string>
    <string name="keywords_location" msgid="8016374808099706213">"netoliese, vietovė, istorija, ataskaitų teikimas, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"paskyra, pridėti paskyrą, darbo profilis, pridėti paskyrą, pašalinti ištrinti"</string>
    <string name="keywords_users" msgid="3497517660077620843">"apribojimas, riboti, ribotas"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"teksto taisymas, taisyti, garsas, vibruoti, automatinis, kalba, gestas, pasiūlyti, pasiūlymas, tema, įžeidžiantis, žodis, tipas, jaustukai, tarptautinis"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"nustatyti iš naujo, nuostatos, numatytosios"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"programos, atsisiųsti, sistema"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"programos, leidimai, sauga"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"programos, numatytosios"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"nepaisyti optimizavimo nustatymų, snustelėti, programų budėjimo režimas"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"ryški, RGB, sRGB, spalva, natūrali, standartinė"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, skyra, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"spalvų temperatūra, D65, D73, balta, geltona, mėlyna, šilta, šalta"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"slysti ir atrakinti, slaptažodis, šablonas, PIN kodas"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"ekrano prisegimas"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"darbo iššūkis, darbas, profilis"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"darbo profilis, tvarkomas profilis, suvienodinti, suvienodinimas, darbas, profilis"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"budrus, miegas, neužrakinti, palikti atrakintą sulenkus, sulenkimas, uždarymas, sulenkti, uždaryti, ekranas išjungtas"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gestai"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"Wallet"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"mokėti, paliesti, mokėjimai"</string>
    <string name="keywords_backup" msgid="707735920706667685">"atsarginė kopija, kurti atsarginę kopiją"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"veidas, atrakinti, autentifikavimas, prisijungti"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"veidas, atrakinti, autentifikavimas, prisijungti, kontrolinis kodas, biometrinė sistema"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"IMEI, MEID, MIN, PRL versija, IMEI SV"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"tinklas, mobiliojo ryšio tinklo būsena, paslaugos būsena, signalo stiprumas, mobiliojo ryšio tinklo tipas, tarptinklinis ryšys"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"tinklas, mobiliojo ryšio tinklo būsena, paslaugos būsena, signalo stiprumas, mobiliojo ryšio tinklo tipas, tarptinklinis ryšys, EID"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"tinklas, mobiliojo ryšio tinklo būsena, paslaugos būsena, signalo stiprumas, mobiliojo ryšio tinklo tipas, tarptinklinis ryšys, ICCID"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"tinklas, mobiliojo ryšio tinklo būsena, paslaugos būsena, signalo stiprumas, mobiliojo ryšio tinklo tipas, tarptinklinis ryšys, ICCID, EID"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"EID"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"serijos numeris, aparatinės įrangos versija"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"akumuliatoriaus informacija, pagaminimo data, ciklų skaičius, pirmas naudojimas"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"„Android“ saugos pataisos lygis, nemoduliuotų signalų įrangos versija, branduolio versija"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"tema, šviesus, tamsus, režimas, jautrumas šviesai, fotofobija, padaryti tamsesnį, patamsinti, tamsus režimas, migrena"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"Tamsi tema"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"riktas"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Aplinkos ekranas, užrakinimo ekranas"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"užrakinimo ekrano pranešimas, pranešimai"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"veidas"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"kontrolinis kodas, pridėti kontrolinį kodą"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"veidas, kontrolinis kodas, pridėti kontrolinį kodą"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"laikrodžio atrakinimas, pridėti laikrodžio atrakinimą"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"pritemdyti ekraną, jutiklinis ekranas, akumuliatorius, išmanusis šviesumas, dinaminis šviesumas, automatinis šviesumas"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"išmanusis, užtemdyti ekraną, miego būsena, akumuliatorius, skirtasis laikas, dėmesys, pateiktis, ekranas, neaktyvumas"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"fotoaparatas, išmanusis, automatiškai pasukti, automatinis pasukimas, pasukti, apversti, pasukimas, stačia, gulsčia, orientacija, vertikali, horizontali"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"atnaujinti, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"dnd, tvarkaraštis, pranešimai, blokuoti, tyla, vibruoti, miego būsena, darbas, fokusavimas, garsas, nutildyti, diena, savaitės diena, savaitgalis, savaitės naktis, renginys"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"ekranas, užrakinimo laikas, skirtasis laikas, užrakinimo ekranas"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"atmintis, talpykla, duomenys, ištrinti, išvalyti, atlaisvinti, vieta"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"prijungtas, įrenginys, ausinės, virtualiosios realybės įrenginys, garsiakalbis, belaidis, susieti, ausinukas, muzika, medija"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"fonas, tema, tinklelis, tinkinti, suasmeninti"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"piktograma, paryškinimas, spalva, pagrindinis ekranas, užrakinimo ekranas, spartusis klavišas, laikrodžio dydis"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"numatytasis, padėjėjas"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"mokėjimas, numatytoji"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"gaunamas pranešimas"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"usb kaip modemas naudojamas įrenginys, Bluetooth kaip modemas naudojamas įrenginys, wifi viešosios interneto prieigos taškas"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"lietimo technologija, vibruoti, vibravimas"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"lietimo technologija, vibruoti, ekranas, jautrumas"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"lietimo technologija, vibruoti, telefonas, skambinti, jautrumas, skambutis"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"lietimo technologija, vibruoti, telefonas, skambutis, skambinti, palaipsniui"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"lietimo technologija, vibruoti, jautrumas, pranešimas"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"lietimo technologija, vibruoti, jautrumas, signalas"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"lietimo technologija, vibruoti, jautrumas, medija"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"lietimo technologija, vibruoti, vibravimas"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"akumuliatoriaus tausojimo priemonė, fiksuotas, išlaikyti, energijos tausojimo priemonė, akumuliatorius"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"veiksmų seka, tvarkaraštis, akumuliatoriaus tausojimo priemonė, energijos tausojimo priemonė, akumuliatorius, automatinis, procentai"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"„VoLTE“, išplėstinės skambinimo parinktys, 4G skambinimas"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"Vo5G, VoNR, išplėstinės skambinimo parinktys, 5G skambinimas"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"pridėti kalbą"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"teksto dydis, didelis spaudinys, didelis šriftas, didelis tekstas, sutrikusio regėjimo asmuo, padaryti tekstą didesnį, šrifto didinimo priemonė, šrifto padidinimas"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"visada įjungta ekrano užsklanda, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"NFC, žyma, skaitytuvas"</string>
    <string name="keywords_keyboard_vibration" msgid="6485149510591654697">"klaviatūra, lietimo technologija, vibruoti,"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Garsumas, vibravimas, netrukdymo režimas"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Medijų garsumas"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Perdavimo garsumas"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Skambučio garsumas"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Signalo garsumas"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Skambučių ir nustatymų garsum."</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Skambučio garsumas"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Pranešimo garsumas"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Tylus skambutis"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Vibracija skambinant"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Pranešimų garsumas nutildytas, įrenginys vibruos sulaukus pranešimų"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"Nutildyta: <xliff:g id="VOLUME_TYPE">%1$s</xliff:g>"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Nepasiekiama, nes skambutis nutildytas"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Telefono skambėjimo tonas"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Numatytasis pranešimo garsas"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Programos pateiktas garsas"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Numatytasis pranešimo garsas"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Numatytasis signalo garsas"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Pirmiausia vibruoti, tada palaipsniui skambinti"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"Erdvinis garsas"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Skambinimo skydelio tonai"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Ekrano užrakinimo garsas"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Įkrovimo garsai ir vibravimas"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Prijungimo prie doko garsai"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Palietimo ir paspaudimo garsai"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Visada rodyti piktogramą vibravimo režimu"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Prie doko prij. garsiak. gars."</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Visi garso įrašai"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Tik medijų garso įrašai"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Tyla"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tonai"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibravimas"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Įjungti garsus"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Subtitrai realiuoju laiku"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Taikyti automatinius medijos subtitrus"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Laidinės ausinės"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Kokybiškesnis suderinamos medijos garsas"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Išjungta"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Įjungta / <xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Įjungta / <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> ir <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Taip pat galite įjungti Erdvinio garso funkciją „Bluetooth“ įrenginiams."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Prijungtų įrenginių nustatymai"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Nė vieno}=1{Nustatytas 1 tvarkaraštis}one{Nustatytas # tvarkaraštis}few{Nustatyti # tvarkaraščiai}many{Nustatyta # tvarkaraščio}other{Nustatyta # tvarkaraščių}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Netrukdymo režimas"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Gauti pranešimus tik iš svarbių žmonių ar programų"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Pertraukčių apribojimas"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Netrukdymo režimo įjungimas"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Signalai ir medijos garsai gali trikdyti"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Tvarkaraščiai"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Tvarkaraščių trynimas"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Ištrinti"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Redaguoti"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Tvarkaraščiai"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Tvarkaraštis"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Tvarkaraštis"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Nutildykite telefoną tam tikru metu"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Nustatykite netrukdymo režimo taisykles"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Tvarkaraštis"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Naudoti tvarkaraštį"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Leisti pertrauktis, skleidžiančias garsą"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokuoti vaizdinius trikdžius"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Leisti vaizdinius signalus"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Paslėptų pranešimų pateikties parinktys"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Kai įjungtas netrukdymo režimas"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Neskambėti gavus pranešimų"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Matysite pranešimus ekrane"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Gavus pranešimą telefonas neskleis garso ir nevibruos."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Nieko nerodyti arba neskambėti gavus pranešimų"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Nematysite arba negirdėsite pranešimų"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Jūsų telefonas nerodys naujų ar esamų pranešimų, nevibruos ir neskambės. Atminkite, kad svarbūs pranešimai apie įrenginio veiklą ir būseną vis tiek bus rodomi.\n\nIšjungę netrukdymo režimą praleistus pranešimus rasite perbraukę žemyn iš ekrano viršaus."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Tinkinti"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Įgalinti tinkintą nustatymą"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Pašalinti tinkintą nustatymą"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Neskambėti gavus pranešimų"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Iš dalies paslėpta"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Nieko nerodyti arba neskambėti gavus pranešimų"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Tinkinti apribojimai"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Kai ekranas įjungtas"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Kai ekranas išjungtas"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Nutildyti garsą ir išjungti vibravimą"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Neįjungti ekrano"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Nemirksėti"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Nerodyti pranešimų ekrane"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Slėpti būsenos juostos piktogramas ekrano viršuje"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Slėpti pranešimų taškus programų piktogramose"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Nepažadinti gavus pranešimų"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Slėpti išskleidžiamajame skydelyje"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Niekada"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Kai ekranas išjungtas"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Kai ekranas įjungtas"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Garsas ir vibravimas"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Pranešimų garsas, vibravimas ir kai kurie vaizdiniai ženklai"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Pranešimų garsas, vibravimas ir vaizdiniai ženklai"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Būtini pagrindinės įrenginio veiklos ir būsenos pranešimai niekada nebus slepiami."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Nėra"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"kitos parinktys"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Pridėti"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Įjungti"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Įjungti dabar"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Išjungti dabar"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Netrukdymo režimas įjungtas iki <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Netrukdymo režimas bus įjungtas, kol jį išjungsite"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Netrukdymo režimą automatiškai įjungė tvarkaraštis („<xliff:g id="RULE_NAME">%s</xliff:g>“)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Netrukdymo režimą automatiškai įjungė programa („<xliff:g id="APP_NAME">%s</xliff:g>“)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Netrukdymo režimas įjungtas „<xliff:g id="RULE_NAMES">%s</xliff:g>“ taikant tinkintus nustatymus."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Žr. tinkintus nustatymus"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Tik prioritetiniai"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"Įjungta / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Įjungta"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Klausti kaskart"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Kol išjungsite"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 valanda}one{# valanda}few{# valandos}many{# valandos}other{# valandų}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minutė}one{# minutė}few{# minutės}many{# minutės}other{# minučių}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Išjungta}=1{Išjungta; 1 tvarkaraštis gali įsijungti automatiškai}one{Išjungta; # tvarkaraštis gali įsijungti automatiškai}few{Išjungta; # tvarkaraščiai gali įsijungti automatiškai}many{Išjungta; # tvarkaraščio gali įsijungti automatiškai}other{Išjungta; # tvarkaraščių gali įsijungti automatiškai}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Kas gali trikdyti netrukdymo režimu"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Žmonės"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Programos"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Signalai ir kitos pertrauktys"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Tvarkaraščiai"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Sparčiųjų nustatymų trukmė"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Bendrieji"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Įjungus netrukdymo režimą garsas ir vibravimas bus nutildomi, išskyrus anksčiau nurodytus elementus, kuriuos leidžiate."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Tinkinti nustatymai"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Peržiūrėti tvarkaraštį"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Supratau"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Pranešimai"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Trukmė"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Pranešimai, įvykiai ir priminimai"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Įjungus netrukdymo režimą pranešimai, priminimai ir įvykiai bus nutildomi, išskyrus anksčiau nurodytus elementus, kuriuos leidžiate. Galite koreguoti nustatymus, kad jūsų šeimos nariai, draugai arba kiti kontaktai galėtų su jumis susisiekti."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Atlikta"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Nustatymai"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Nieko nerodyti arba neskambėti gavus pranešimų"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Neskambėti gavus pranešimų"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Nematysite arba negirdėsite pranešimų. Skambučiai nuo žvaigždute pažymėtų kontaktų ir pakartotinai skambinančiųjų leidžiami."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Dabartinis nustatymas)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Pakeisti netrukdymo režimo pranešimų nustatymus?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Darbo profilio garsai"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Naudoti asmen. profilio garsus"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Naudoti tokius pat garsus kaip asmeniniame profilyje"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Darbo telef. skambėjimo tonas"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Numatytasis darbo pranešimo garsas"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Numatytasis darbo signalo garsas"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Toks pat kaip asmeninio profilio"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Naudoti asmeninio profilio garsus?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Patvirtinti"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Darbo profilyje bus naudojami tokie pat garsai kaip asmeniniame profilyje"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Pranešimai"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Pranešimų istorija, pokalbiai"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Pokalbis"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Tvarkymas"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Programų pranešimai"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Atskirų programų pranešimų valdymas"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Bendrieji"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Darbo profilio pranešimai"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Darbo profilis"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Adaptyviųjų pranešimų prioritetas"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Žemesnio prioriteto pranešimus automatiškai nustatyti kaip netrikdančius"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Prisitaikantis pranešimų reitingavimas"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Automatiškai reitinguoti pranešimus pagal atitikimą"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Atsiliepimai apie adaptyviuosius pranešimus"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Nurodyti pranešimų koregavimus ir rodyti parinktį teikti atsiliepimus apie sistemą"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Iš naujo nustatyti pranešimų svarbą"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Iš naujo nustatykite naudotojo pakeistus svarbos nustatymus ir leiskite pranešimų pagelbikliui priskirti prioritetą"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Siūlomi veiksmai ir atsakymai"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Automatiškai rodyti siūlomus veiksmus ir atsakymus"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Naujausių ir atidėtų pranešimų rodymas"</string>
    <string name="notification_history" msgid="8663811361243456201">"Pranešimų istorija"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Pranešimų istorijos naudojimas"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Pranešimų istorija išjungta"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Įjunkite pranešimų istoriją, jei norite peržiūrėti naujausius ir atidėtus pranešimus"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Naujausių pranešimų nėra"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Naujausi ir atidėti pranešimai bus rodomi čia"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"peržiūrėti pranešimų nustatymus"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"atidaromas pranešimas"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Leisti nustatyti pranešimus snausti"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Pranešimo taškas programos piktogramoje"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Burbulai"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Burbulai"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Rodyti šio pokalbio burbulą"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Rodyti slankiąją piktogramą programų viršuje"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Įjungti debesėlius įrenginyje?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Įjungus burbulus šioje programoje taip pat bus įjungti burbulai įrenginyje.\n\nTai turi įtakos kitoms programoms ar pokalbiams, kuriuose leidžiami burbulai."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Įjungti"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Atšaukti"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Įjungti / pokalbiai gali būti rodomi kaip slankiosios piktogramos"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Leidimas programoms rodyti burbulus"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Kai kurie pokalbiai bus rodomi kaip slankiosios piktogramos kitų programų viršuje"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Visi pokalbiai bus pateikiami kaip burbulai"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Pasirinkti pokalbiai bus pateikiami kaip burbulai"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Nerodyti burbulų"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Pokalbiai"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Visi pokalbiai bus pateikiami kaip burbulai, išskyrus nurodytus toliau"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Išjungti šio pokalbio burbulus"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Įjungti šio pokalbio burbulus"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Perbraukite dešinėn, kad atsisakytumėte, arba kairėn, kad būtų rodomas meniu"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Perbraukite kairėn, kad atsisakytumėte, arba dešinėn, kad būtų rodomas meniu"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Slėpti tylius pranešimus būsenos juostoje"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Mirksinti šviesa"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privatumas"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Praleisti užrakinimo ekraną"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Atrakinę tiesiogiai eikite į paskutinį naudotą ekraną. Pranešimai nebus rodomi užrakinimo ekrane. Peržiūrėkite perbraukę žemyn iš viršaus."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"užrakinimo ekranas, praleisti, apeiti"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Kai darbo profilis užrakintas"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Užrakinimo ekrane rodyti tik naujus pranešimus"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Automatiškai pašalinti anksčiau žiūrėtus pranešimus iš užrakinimo ekrano"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Pranešimai užrakinimo ekrane"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Rodyti pokalbius, numatytuosius ir tylius"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Rodyti pokalbius, numatytuosius ir tylius"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Slėpti tylius pokalbius ir pranešimus"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Nerodyti jokių pranešimų"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Neskelbtini pranešimai"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Rodyti neskelbtiną turinį, kai ekranas užrakintas"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Neskelbtini darbo profilio pranešimai"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Rodyti neskelbtiną darbo profilio turinį, kai ekranas užrakintas"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Rodyti visą pranešimo turinį"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Neskelbtiną turinį rodyti, tik kai atrakinta"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Visiškai nerodyti pranešimų"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6326229471276829730">"Kas turėtų būti rodoma užrakinimo ekrane?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Užrakinimo ekranas"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Rodyti visą darbo pranešimų turinį"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Slėpti neskelbtiną darbo turinį"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Kaip norite matyti profilio pranešimus, kai įrenginys užrakintas?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profilio pranešimai"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Pranešimai"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Programų pranešimai"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Pranešimo kategorija"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Elgsena"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Pokalbiai"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Pokalbių skiltis"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Leisti programai naudoti pokalbių skiltį"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Ne pokalbis"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Pašalinti iš pokalbių skilties"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Tai yra pokalbis"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Pridėti prie pokalbių skilties"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Nėra jokių prioritetinių pokalbių"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# prioritetinis pokalbis}one{# prioritetinis pokalbis}few{# prioritetiniai pokalbiai}many{# prioritetinio pokalbio}other{# prioritetinių pokalbių}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Svarbiausi pokalbiai"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Rodyti pokalbių skilties viršuje kaip slankiuosius burbulus"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Rodyti pokalbių skilties viršuje"</string>
    <string name="other_conversations" msgid="551178916855139870">"Ne prioritetiniai pokalbiai"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Pakeisti pokalbiai"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Paskutiniai pokalbiai"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Išvalyti naujausius pokalbius"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Pašalinti pastarieji pokalbiai"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Pokalbis pašalintas"</string>
    <string name="clear" msgid="5092178335409471100">"Išvalyti"</string>
    <string name="clear_conversation" msgid="5564321180363279096">"Išvalyti <xliff:g id="CONVERSATION_NAME">%1$s</xliff:g>."</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Svarbiausi ir pakeisti pokalbiai bus rodomi čia"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Kai pažymėsite pokalbį kaip svarbiausią ar atliksite kitų pokalbio keitimų, jie bus rodomi čia. \n\nJei norite pakeisti pokalbių nustatymus: \nslinkite ekranu iš viršaus žemyn, tada atidarę išskleidžiamąjį skydelį palieskite ir palaikykite pokalbį."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Sumažinti"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Iššokantysis langas ekrane"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Tylūs"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Numatytieji"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Leisti pertrauktis"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Leisti programai skambėti, vibruoti ir (arba) rodyti pranešimus ekrane"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritetas"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Rodoma pokalbių skilties viršuje, rodoma kaip slankusis burbulas, pateikiama profilio nuotrauka užrakinimo ekrane"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ nepalaiko daugelio pokalbių funkcijų. Negalite nustatyti pokalbio kaip prioriteto ir pokalbiai nebus rodomi kaip slankieji burbulai."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Išskleidžiamajame skydelyje sutraukti pranešimus į vieną eilutę"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Neskamba ir nevibruoja"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Neskamba, nevibruoja ir rodoma apatinėje pokalbių skilties dalyje"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Gali skambėti arba vibruoti, atsižvelgiant į įrenginio nustatymus"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Kai įrenginys atrakintas, pranešimai rodomi kaip reklamjuostė ekrano viršuje"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Visi „<xliff:g id="APP_NAME">%1$s</xliff:g>“ pranešimai"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Visi „<xliff:g id="APP_NAME">%1$s</xliff:g>“ pranešimai"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Maždaug # pranešimas per dieną}one{Maždaug # pranešimas per dieną}few{Maždaug # pranešimai per dieną}many{Maždaug # pranešimo per dieną}other{Maždaug # pranešimų per dieną}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Maždaug # pranešimas per savaitę}one{Maždaug # pranešimas per savaitę}few{Maždaug # pranešimai per savaitę}many{Maždaug # pranešimo per savaitę}other{Maždaug # pranešimų per savaitę}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Niekada"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Įrenginių ir programų pranešimai"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Valdykite, kurios programos ir įrenginiai gali nuskaityti pranešimus"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Prieiga prie darbo profilio pranešimų užblokuota"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Patobulinti pranešimai"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Gaukite siūlomus veiksmus, atsakymus ir daugiau"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Nėra"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Jokios įdiegtos programos nepateikė pranešimo prieigos užklausos."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Leisti prieigą prie pranešimų"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"12 versijos „Android“ patobulinti pranešimai pakeitė „Android“ prisitaikančius pranešimus. Ši funkcija rodo siūlomus veiksmus bei atsakymus ir tvarko jūsų pranešimus. \n\nPatobulintų pranešimų funkcija gali pasiekti pranešimų turinį, įskaitant asmens informaciją (pvz., kontaktų vardus ir pranešimus). Ši funkcija taip pat gali atsisakyti pranešimų arba į juos atsakyti, pvz., atsakyti į telefono skambučius ir valdyti netrukdymo režimą."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Leisti „<xliff:g id="SERVICE">%1$s</xliff:g>“ prieigą prie pranešimų?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Programa „<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>“ galės skaityti visus pranešimus, įskaitant asmens informaciją, pvz., kontaktų vardus, nuotraukas ir gautų pranešimų tekstą. Ši programa taip pat galės atidėti pranešimus ar jų atsisakyti arba imtis veiksmų su pranešimuose esančiais mygtukais, įskaitant atsakymą į telefono skambučius. \n\nPrograma taip pat galės įjungti ar išjungti netrukdymo režimą ir keisti susijusius nustatymus."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Programa „<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>“ galės atlikti toliau nurodytus veiksmus."</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Pranešimų skaitymas"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Leidžiama skaityti jūsų pranešimus, įskaitant asmens informaciją, pvz., kontaktus, pranešimus ir nuotraukas."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Atsakymas į pranešimus"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Leidžiama atsakyti į pranešimus ir imtis veiksmų su pranešimuose esančiais mygtukais, įskaitant pranešimų atidėjimą ar atsisakymą bei atsakymą į skambučius."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Nustatymų keitimas"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Leidžiama įjungti ar išjungti netrukdymo režimą ir keisti susijusius nustatymus."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Jei išjungsite „<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>“ prieigą prie pranešimų, prieiga prie režimo „Netrukdyti“ taip pat gali būti išjungta."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Išjungti"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Atšaukti"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Realusis laikas"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Esami pranešimai iš naudojamų programų, navigacija, telefono skambučiai ir kt."</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Pokalbiai"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS, teksto ir kiti pranešimai"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Pranešimai"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Gali skambėti arba vibruoti, atsižvelgiant į nustatymus"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Begarsis"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Pranešimai, pateikiami be garso ar vibracijos"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Leidžiama"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Neleidžiama"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Žr. visas programas"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Pakeiskite kiekvienos pranešimus siunčiančios programos nustatymus"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Įrenginyje rodomos programos"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Ši programa nepalaiko išplėstinių nustatymų"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Daugiau nustatymų"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Daugiau nustatymų pasiekiama šioje programoje"</string>
    <string name="notification_polite_title" msgid="6121016426991791557">"Pranešimų neaktyvumo laikotarpis"</string>
    <string name="notification_polite_all_apps" msgid="1118651561594250059">"Taikyti neaktyvumo laikotarpį visiems pranešimams"</string>
    <string name="notification_polite_all_apps_summary" msgid="540268373207498126">"Palaipsniui sumažinti pranešimų garsumą, kai gaunate daug vienas po kito pateikiamų pranešimų iš tos pačios programos"</string>
    <string name="notification_polite_conversations" msgid="8197695136727245741">"Taikyti neaktyvumo laikotarpį pokalbiams"</string>
    <string name="notification_polite_conversations_summary" msgid="2677141765664359994">"Palaipsniui sumažinti pranešimų garsumą, kai gaunate daug to paties pokalbio pranešimų per trumpą laiką"</string>
    <string name="notification_polite_disabled" msgid="1378078021594282842">"Nenaudoti pranešimų neaktyvumo laikotarpio"</string>
    <string name="notification_polite_disabled_summary" msgid="1145341260283746936">"Niekada nesumažinti pranešimų garsumo, neatsižvelgiant į vienas po kito pateiktų pranešimų iš tos pačios programos skaičių"</string>
    <string name="notification_polite_vibrate_unlocked" msgid="6142573851761357903">"Vibruoti, kai atrakinta"</string>
    <string name="notification_polite_vibrate_unlocked_summary" msgid="1678472892282874459">"Vibruoti, tik kai ekranas užrakintas"</string>
    <string name="notification_polite_work" msgid="8823596456640216391">"Taikyti darbo profiliams"</string>
    <string name="notification_polite_work_summary" msgid="8260947839104352075">"Taikyti pranešimų neaktyvumo laikotarpio nustatymus iš asmeninio profilio darbo profiliui"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Pagalbinės virtualiosios realybės paslaugos"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Nėra įdiegtų programų, kurios pateikė užklausą būti vykdomos kaip pagalbinės virtualiosios realybės paslaugos."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Leisti „<xliff:g id="SERVICE">%1$s</xliff:g>“ pasiekti virtualiosios realybės paslaugą?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"„<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g>“ galės veikti, kai programas naudosite virtualiosios realybės režimu."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Kai įrenginys veikia VR režimu"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Sumažinti suliejimą (rekomenduojama)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Sumažti mirgėjimą"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Vaizdas vaizde"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Nė viena iš įdiegtų programų nepalaiko vaizdo vaizde režimo"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"vaizdas vaizde"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Vaizdas vaizde"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Leisti vaizdą vaizde"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Leisti šiai programai kurti vaizdo vaizde langą, kol programa yra atidaryta arba ją uždarius (pvz., kad galėtumėte ir toliau žiūrėti vaizdo įrašą). Šis langas rodomas virš kitų naudojamų programų."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Prijungtos darbo ir asmeninės programos"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Prijungta"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Neprijungta"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Nėra prijungtų programų"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"kelių profilių prijungta programa programos darbo ir asmeninė"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Prijungta"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Prijungti šias programas"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Prijungtos programos bendrina leidimus ir gali pasiekti viena kitos duomenis."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Prijunkite programas, tik jei pasitikite jomis ir esate tikri, kad jos nebendrins jūsų asmens duomenų su IT administratoriumi."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Galite bet kada atsieti programas įrenginio privatumo nustatymuose."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Patikėti programai „<xliff:g id="NAME">%1$s</xliff:g>“ jūsų asmens duomenis?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Prijunkite programas, tik jei pasitikite jomis ir esate tikri, kad jos nebendrins jūsų asmens duomenų su IT administratoriumi."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Programos duomenys"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Ši programa gali pasiekti duomenis jūsų asmeninėje programoje „<xliff:g id="NAME">%1$s</xliff:g>“."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Leidimai"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Ši programa gali naudoti jūsų asmeninės programos „<xliff:g id="NAME">%1$s</xliff:g>“ leidimus, pvz., pasiekti vietovę, saugyklą ar kontaktus."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Nėra prijungtų programų"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{Prijungta # programa}one{Prijungta # programa}few{Prijungtos # programos}many{Prijungta # programos}other{Prijungta # programų}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Kad prijungtumėte šias programas, įdiekite programą „<xliff:g id="NAME">%1$s</xliff:g>“ darbo profilyje"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Kad prijungtumėte šias programas, įdiekite programą „<xliff:g id="NAME">%1$s</xliff:g>“ asmeniniame profilyje"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Palieskite, kad gautumėte programą"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Prieiga „Netrukdyti“"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Leisti netrukdymo režimą"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Jokios įdiegtos programos nepateikė prieigos „Netrukdyti“ užklausos"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Neleidote šios programos pranešimų"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"„Android“ jūsų prašymu blokuoja šios kategorijos pranešimus, kad jie nebūtų rodomi šiame įrenginyje"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"„Android“ jūsų prašymu blokuoja šios grupės pranešimus, kad jie nebūtų rodomi šiame įrenginyje"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Ši programa nesiunčia pranešimų"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategorijos"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Kita"</string>
    <string name="no_channels" msgid="4716199078612071915">"Ši programa nepaskelbė jokių pranešimų"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Papildomi programos nustatymai"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{Pašalinta # kategorija}one{Pašalinta # kategorija}few{Pašalintos # kategorijos}many{Pašalinta # kategorijos}other{Pašalinta # kategorijų}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokuoti viską"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Niekada nerodyti šių pranešimų"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Rodyti pranešimus"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Niekada nerodyti pranešimų skydelyje ar išoriniuose įrenginiuose"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Leisti rodyti pranešimus viso ekrano režimu"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Leiskite rodyti pranešimus viso ekrano režimu, kai įrenginys užrakintas."</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Leisti pranešimo tašką"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Rodyti pranešimo tašką"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Nepaisyti netrukdymo režimo"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Leisti ir toliau teikti šiuos pranešimus, kai įjungtas netrukdymo režimas"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Užrakinimo ekranas"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Atlikta"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Mirksinti šviesa"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibravimas"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Garsas"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioritetiniai"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Tvarkaraščio pavadinimas"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Įveskite tvarkaraščio pavadinimą"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Toks tvarkaraščio pavadinimas jau naudojamas"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Pridėti daugiau"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Pridėti įvykio tvarkaraštį"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Pridėti laiko tvarkaraštį"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Pasirinkite tvarkaraščio tipą"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Ištrinti taisyklę „<xliff:g id="RULE">%1$s</xliff:g>“?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Ištrinti"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Šių nustatymų dabar pakeisti negalima. Programa („<xliff:g id="APP_NAME">%1$s</xliff:g>“) automatiškai įjungė netrukdymo režimą su tinkinta elgsena."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Šių nustatymų dabar pakeisti negalima. Programa automatiškai įjungė netrukdymo režimą su tinkinta elgsena."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Šių nustatymų dabar pakeisti negalima. Neautomatiškai įjungtas netrukdymo režimas su tinkinta elgsena."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Laikas"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Įvykis"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Per įvykius iš"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Bet kuris kalendorius"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Kai atsakymas yra"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"„Taip“, „Galbūt“ arba „Neatsakyta“"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"„Taip“ arba „Galbūt“"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Taip"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Taisyklė nerasta."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Įjungta / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Dienos"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Nėra"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Įspėjimas gali nepaisyti pabaigos laiko"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Tvarkaraštis išjungiamas, kai suskamba signalas"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Netrukdymo režimo elgsena"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Naudoti numatytuosius nustatymus"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Kurti tinkintus šio tvarkaraščio nustatymus"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Skirta „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>“"</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g>–<xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Pokalbiai"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Visi pokalbiai"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Svarbiausi pokalbiai"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"prioritetiniai pokalbiai"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Nėra"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Nė vieno}=1{1 pokalbis}one{# pokalbis}few{# pokalbiai}many{# pokalbio}other{# pokalbių}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Kas gali trikdyti"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Net jei pranešimų ar skambučių programos negali teikti jums pranešimų, čia pasirinkti žmonės vis tiek gali pasiekti jus naudodami šias programas"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Skambučiai"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Skambučiai"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"skambučiai"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Skambučiai, kurie gali trikdyti"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Kad užtikrintumėte, jog įrenginys skambės priimant leidžiamus skambučius, patikrinkite, ar jame nustatytas skambėjimo režimas"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Veikiant „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>“ blokuojami gaunamieji skambučiai. Galite koreguoti nustatymus ir leisti draugams, šeimos nariams ar kitiems kontaktams jus pasiekti."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Žvaigždute pažymėti kontaktai"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Nė vieno}=1{{contact_1}}=2{{contact_1} ir {contact_2}}=3{{contact_1}, {contact_2} ir {contact_3}}one{{contact_1}, {contact_2} ir dar # žmogus}few{{contact_1}, {contact_2} ir dar # žmonės}many{{contact_1}, {contact_2} ir dar # žmogaus}other{{contact_1}, {contact_2} ir dar # žmonių}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Nėra pavadinimo)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Pranešimai"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"pranešimai"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Pranešimai"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Pranešimai, kurie gali trikdyti"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Kad užtikrintumėte, jog įrenginys skambės priimant leidžiamus pranešimus, patikrinkite, ar jame nustatytas skambėjimo režimas"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Veikiant „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>“ blokuojami gaunami pranešimai. Galite koreguoti nustatymus ir leisti draugams, šeimos nariams ar kitiems kontaktams jus pasiekti."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Visi pranešimai gali jus pasiekti"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Visi skambučiai gali jus pasiekti"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Nė vieno}=1{1 kontaktas}one{# kontaktas}few{# kontaktai}many{# kontakto}other{# kontaktų}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Bet kas"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontaktai"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Žvaigždutėmis pažymėti kontaktai"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Niekas"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Nėra"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Signalai"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Iš laikmačių, signalų, saugos sistemų ir kitų programų"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"signalai"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Signalai"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Medijos garsai"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Vaizdo įrašų, žaidimų ir kitos medijos garsai"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"medija"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Medija"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Lietimo garsai"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Klaviatūros ir kitų mygtukų garsai"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"lietimo garsai"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Lietimo garsai"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Priminimai"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Iš užduočių ir priminimų"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"priminimai"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Priminimai"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Kalendoriaus įvykiai"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Iš būsimų kalendoriaus įvykių"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"įvykiai"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Įvykiai"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Leisti programoms nepaisyti"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Programos, kurios gali trikdyti"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Pasirinkti daugiau programų"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Nepasirinkta jokių programų"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Jokios programos negali trikdyti"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Pridėti programų"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Visi pranešimai"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Kai kurie pranešimai"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Pasirinkti žmonės vis tiek gali jus pasiekti, net jei neleidžiate programoms trikdyti"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Jokios programos negali trikdyti}=1{„{app_1}“ gali trikdyti}=2{„{app_1}“ ir „{app_2}“ gali trikdyti}=3{„{app_1}“, „{app_2}“ ir „{app_3}“ gali trikdyti}one{„{app_1}“, „{app_2}“ ir dar # programa gali trikdyti}few{„{app_1}“, „{app_2}“ ir dar # programos gali trikdyti}many{„{app_1}“, „{app_2}“ ir dar # programos gali trikdyti}other{„{app_1}“, „{app_2}“ ir dar # programų gali trikdyti}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Programos"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Pranešimai, kurie gali trikdyti"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Leisti visus pranešimus"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Niekas negali trikdyti}=1{„{sound_category_1}“ gali trikdyti}=2{„{sound_category_1}“ ir „{sound_category_2}“ gali trikdyti}=3{„{sound_category_1}“, „{sound_category_2}“ ir „{sound_category_3}“ gali trikdyti}one{„{sound_category_1}“, „{sound_category_2}“ ir dar # garsas gali trikdyti}few{„{sound_category_1}“, „{sound_category_2}“ ir dar # garsai gali trikdyti}many{„{sound_category_1}“, „{sound_category_2}“ ir dar # garso gali trikdyti}other{„{sound_category_1}“, „{sound_category_2}“ ir dar # garsų gali trikdyti}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Niekas negali trikdyti"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Niekas negali trikdyti"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Kai kurie žmonės gali trikdyti"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Visi žmonės gali trikdyti"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Pakartotinai skambinantys"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Leisti pakartotinai skambinančius žm."</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"bet kas"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"Kontaktai"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"žvaigždute pažymėti kontaktai"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"pakartotinai skambinantys žmonės"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> ir <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Jei asmuo skambina antrą kartą per <xliff:g id="MINUTES">%d</xliff:g> min. laikotarpį"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Pradžios laikas"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Pabaigos laikas"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> kitą dieną"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Pakeisti tik į signalus neribotam laikui"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Pakeisti į signalus tik vienai minutei iki {time}}one{Pakeisti į signalus tik # minutei (iki {time})}few{Pakeisti į signalus tik # minutėms (iki {time})}many{Pakeisti į signalus tik # minutės (iki {time})}other{Pakeisti į signalus tik # minučių (iki {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Pakeisti į signalus tik vienai valandai iki {time}}one{Pakeisti į signalus tik # valandai iki {time}}few{Pakeisti į signalus tik # valandoms iki {time}}many{Pakeisti į signalus tik # valandos iki {time}}other{Pakeisti į signalus tik # valandų iki {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Pakeisti tik į signalus iki <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Pakeisti į pertraukimo nustatymą visam laikui"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Perspėjimas"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Uždaryti"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Siųsti atsiliepimą apie šį įrenginį"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Įveskite administratoriaus PIN kodą"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Įjungta"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Išjungta"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Įjungta"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Išjungta"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Įjungta"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Išjungta"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Programos prisegimas"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Prisegta dabartinė programa liks rodinyje tol, kol ją atsegsite. Šią funkciją galima naudoti, pavyzdžiui, leidžiant patikimam draugui žaisti konkretų žaidimą."</string>
    <string name="screen_pinning_description" msgid="5822120806426139396">"Prisegta programa gali atidaryti kitas programas ir pasiekti asmens duomenis. \n\nJei norite naudoti programos prisegimą, atlikite toliau nurodytus veiksmus. 	\n{0,number,integer}. Įjunkite programos prisegimą. 	\n{1,number,integer}. Atidarykite skiltį „Apžvalga“. 	\n{2,number,integer}. Palieskite programos piktogramą ekrano viršuje, tada palieskite „Prisegti“."</string>
    <string name="screen_pinning_guest_user_description" msgid="2307270321127139579">"Prisegta programa gali atidaryti kitas programas ir pasiekti asmens duomenis. \n\nJei norite saugiai bendrinti įrenginį su kitais asmenimis, išbandykite naudotojo svečio profilį. \n\nJei norite naudoti programos prisegimą, atlikite toliau nurodytus veiksmus. 	\n{0,number,integer}. Įjunkite programos prisegimą. 	\n{1,number,integer}. Atidarykite skiltį „Apžvalga“. 	\n{2,number,integer}. Palieskite programos piktogramą ekrano viršuje, tada palieskite „Prisegti“."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Kai programa prisegta \n\n•	 Gali būti pasiekiami asmens duomenys \n		(pvz., kontaktai ir el. pašto turinys) \n•		Prisegta programa gali atidaryti kitas programas \n\nProgramas prisekite tik su žmonėmis, kuriais pasitikite."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Prašyti atrakinimo piešinio prieš atsegant"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Prašyti PIN kodo prieš atsegant"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Prašyti slaptažodžio prieš atsegant"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Užrakinti įrenginį atsegant"</string>
    <string name="confirm_sim_deletion_title" msgid="7262127071183428893">"Patvirtinkite, kad norite ištrinti „eSIM“ kortelę"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Prieš ištrindami „eSIM“ kortelę patvirtinkite savo tapatybę"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Beta versijos išplėstinė atminties apsauga"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Išplėstinė atminties apsauga"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Ši beta versijos funkcija padeda apsaugoti įrenginį nuo riktų, dėl kurių gali kilti saugos pavojų."</string>
    <string name="memtag_on" msgid="824938319141503923">"Įjungta"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Išjungta"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Įjungti paleidus iš naujo"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Išjungti paleidus iš naujo"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Šiuo metu nepasiekiama įrenginyje"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Visada įjungta įrenginyje"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Turėsite iš naujo paleisti įrenginį, kad įjungtumėte ar išjungtumėte išplėstinę atminties apsaugą. Kai ji įjungta, įrenginys gali veikti lėčiau."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Paleisti įrenginį iš naujo?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Turėsite iš naujo paleisti įrenginį, kad įjungtumėte išplėstinę atminties apsaugą."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Turėsite iš naujo paleisti įrenginį, kad išjungtumėte išplėstinę atminties apsaugą."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Paleisti iš naujo"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Ne dabar"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Sužinokite daugiau apie išplėstinę atminties apsaugą."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Šį darbo profilį tvarko:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Tvarkoma naudojant „<xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>“"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Atidaryti pagal numatyt. nustatymus"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Atidaryti palaikomas nuorodas"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Leisti šioje programoje atidaryti žiniatinklio nuorodas"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Nuorodos, kurios atidaromos šioje programoje"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Palaikomos nuorodos"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Kitos numatytosios nuostatos"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Pridėti nuorodą"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Programa gali patvirtinti nuorodas, kad jas būtų galimai automatiškai atidaryti programoje."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# patvirtinta nuoroda}one{# patvirtinta nuoroda}few{# patvirtintos nuorodos}many{# patvirtintos nuorodos}other{# patvirtintų nuorodų}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Ši nuoroda yra patvirtinta ir automatiškai atidaroma šioje programoje.}one{Šios nuorodos yra patvirtintos ir automatiškai atidaromos šioje programoje.}few{Šios nuorodos yra patvirtintos ir automatiškai atidaromos šioje programoje.}many{Šios nuorodos yra patvirtintos ir automatiškai atidaromos šioje programoje.}other{Šios nuorodos yra patvirtintos ir automatiškai atidaromos šioje programoje.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"Gerai"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Rodyti patvirtintų nuorodų sąrašą"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Ieškoma kitų palaikomų nuorodų…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Atšaukti"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# palaikoma nuoroda}one{# palaikoma nuoroda}few{# palaikomos nuorodos}many{# palaikomos nuorodos}other{# palaikomų nuorodų}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Pridėti"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Atidaroma programoje „<xliff:g id="APP_LABEL">%s</xliff:g>“"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"Naudojama: <xliff:g id="SIZE">%1$s</xliff:g> (<xliff:g id="STORAGE_TYPE">%2$s</xliff:g>)"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"vidinė atmintis"</string>
    <string name="storage_type_external" msgid="125078274000280821">"išorinė atmintis"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"Panaudota <xliff:g id="SIZE">%1$s</xliff:g> nuo <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Naudojama atmintinė"</string>
    <string name="change" msgid="273206077375322595">"Keisti"</string>
    <string name="change_storage" msgid="8773820275624113401">"Keisti saugyklą"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Informaciniai pranešimai"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Įjungta"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g> / <xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"Išjungta"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# kategorija išjungta}one{# kategorijų išjungta}few{# kategorijos išjungtos}many{# kategorijos išjungta}other{# kategorijų išjungta}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# papildomas leidimas}one{# papildomas leidimas}few{# papildomi leidimai}many{# papildomo leidimo}other{# papildomų leidimų}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Nėra suteiktų leidimų"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Nėra užklausų dėl leidimų"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Valdykite programų prieigą prie duomenų"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Privatumo informacijos suvestinė"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Rodyti, kurios programos neseniai naudojo leidimus"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Nenaudojamos programos"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# nenaudojama programa}one{# nenaudojama programa}few{# nenaudojamos programos}many{# nenaudojamos programos}other{# nenaudojamų programų}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Nenaudojamos programos nustatymai"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Pristabdyti nenaudojamų programų veiklą"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Pašalinkite leidimus, ištrinkite laikinus failus ir sustabdykite pranešimus"</string>
    <string name="unused_apps_switch_v2" msgid="7464060328451454469">"Tvarkyti programą, jei nenaudojama"</string>
    <string name="unused_apps_switch_summary_v2" msgid="3182898279622036805">"Pašalinti leidimus, ištrinti laikinus failus, sustabdyti pranešimus ir archyvuoti programą"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Visos programos"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Įdiegtos programos"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Akimirksniu įkeliamos programos"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Išjungta"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Išplėstiniai"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Leidimų tvarkytuvė"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Duomenų bendrinimo atnaujinimai pagal vietovę"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Peržiūrėkite programas, kuriose pakeisti vietovės duomenų bendrinimo metodai"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Paliesti ir pažadinti"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Dukart palieskite bet kurioje ekrano vietoje, kad pažadintumėte įrenginį"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Atidarymo nuorodos"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Neatidaryti nepalaikomų nuorodų"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Atidaryti <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Atidaryti <xliff:g id="DOMAIN">%s</xliff:g> ir kitus URL"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Leisti programai atidaryti palaikomas nuorodas"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Klausti kaskart"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Neleisti programai atidaryti nuorodų"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Programa gali tvarkyti # nuorodą}one{Programa gali tvarkyti # nuorodą}few{Programa gali tvarkyti # nuorodas}many{Programa gali tvarkyti # nuorodos}other{Programa gali tvarkyti # nuorodų}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Programa gali tvarkyti toliau pateiktas nuorodas."</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Pagalb. progr. ir įvest. balsu"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Skaitmeninio pagelbiklio pr."</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Numat. skaitm. pagelbiklio pr."</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Sutinku"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Naršyklės programa"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Telefono programa"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistema)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Programų saugykla"</string>
    <string name="usage_access" msgid="5487993885373893282">"Naudojimo prieiga"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Leisti naudojimo prieigą"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Įrenginio naudojimo laikas"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Taikant naudojimo prieigą programa gali stebėti, kokias kitas programas naudojate ir kaip dažnai jas naudojate bei išsamią operatoriaus, kalbos nustatymų ir kitą informaciją."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Atmintis"</string>
    <string name="always_running" msgid="9012705720688200252">"Veikia nuolat (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Veikia kartais (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Veikia retai (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g> / <xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Akumuliatoriaus optimiz."</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Neoptimizuota"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Neoptimizuota"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimizuojamas akumuliatoriaus naudojimas"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Akumuliatoriaus optimizavimas negalimas"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Leisti visada vykdyti programą fone?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Leidžiant „<xliff:g id="APP_NAME">%1$s</xliff:g>“ visada vykdyti fone akumuliatorius gali veikti trumpiau. \n\nTai vėliau galėsite pakeisti skiltyje „Nustatymai“ &gt; „Programos“."</string>
    <string name="battery_summary" msgid="2491764359695671207">"Išnaudota <xliff:g id="PERCENTAGE">%1$s</xliff:g> nuo paskutinio visiško įkrovimo"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"Suvartota <xliff:g id="PERCENTAGE">%1$s</xliff:g> per pastarąsias 24 valandas"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Akumuliatorius nenaudotas nuo paskutinio visiško įkrovimo"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Bendrinti pranešimą apie riktą?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Jūsų IT administratorius pateikė pranešimo apie riktą užklausą, kad galėtų padėti pašalinti triktis šiame įrenginyje. Programos ir duomenys gali būti bendrinami."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Jūsų IT administratorius pateikė pranešimo apie riktą užklausą, kad galėtų padėti pašalinti triktis šiame įrenginyje. Programos bei duomenys gali būti bendrinami ir įrenginys gali laikinai lėčiau veikti."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Šis pranešimas apie riktą bendrinamas su jūsų IT administratoriumi. Jei reikia išsamesnės informacijos, susisiekite su juo."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Bendrinti"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Atmesti"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Duomenys neperkeliami"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Įkrauti prijungtą įrenginį"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Failų perkėlimas"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Žiniatinklio kamera"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Konvertuoti vaizdo įrašus į AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Vaizdo įrašus bus galima leisti naudojant daugiau medijos leistuvių, bet kokybė gali pablogėti"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"USB įrenginio kaip modemo naudojimas"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"USB naudojimas"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Numatytoji USB konfigūracija"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Kai prijungiamas kitas įrenginys ir jūsų telefonas yra atrakintas, taikomi šie nustatymai. Prisijunkite tik prie patikimų įrenginių."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Maitinimo parinktys"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Failų perkėlimo parinktys"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"USB nuostatos"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB valdo"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Prijungtas įrenginys"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Šis įrenginys"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Perjungiama…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Nepavyko perjungti"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Šio įrenginio įkrovimas"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Įkraunamas prijungtas įrenginys"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Failų perkėlimas"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"USB įrenginio kaip modemo naudojimas"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Žiniatinklio kamera"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Failų perkėlimas ir maitinimo tiekimas"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"USB įrenginio kaip modemo naudojimas ir maitinimo tiekimas"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP ir maitinimo tiekimas"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI ir maitinimo tiekimas"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Žiniatinklio kamera ir maitinimo tiekimas"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Fono tikrinimas"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Naudoti tekstą iš ekrano"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Leisti pagalbinei programai pasiekti ekrano turinį kaip tekstą"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Ekrano kopijos naudojimas"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Leisti pagalbinei programai pasiekti ekrano vaizdą"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Ekrano blyksėjimas"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Ekrano kraštai blyksės, kai pagalbinė programa pasieks tekstą iš ekrano ar ekrano kopijos"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Pagalbinė programa gali padėti atsižvelgdama į peržiūrimo ekrano informaciją. Kai kurios programos palaiko tiek paleidimo priemonę, tiek įvesties balsu priemonę, kad galėtų būti naudingos."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Vidutinis atminties naudojimas"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Daugiausia panaudota atminties"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Atminties naudojimas"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Programos naudojimas"</string>
    <string name="memory_details" msgid="6133226869214421347">"Išsami informacija"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Per paskutines 3 val. naudota vid. <xliff:g id="SIZE">%1$s</xliff:g> atminties"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Per paskutines 3 val. nenaudota jokios atminties"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Rūšiuoti pagal vid. naudojimą"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Rūšiuoti pagal didžiausią naudojimą"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Našumas"</string>
    <string name="total_memory" msgid="5244174393008910567">"Bendra atminties vieta"</string>
    <string name="average_used" msgid="690235917394070169">"Vidutiniškai naudoja (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Laisva"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Programų naudojama atmintis"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{Viena programa naudojo atmintį per tiek laiko: {time}}one{# programa naudojo atmintį per tiek laiko: {time}}few{# programos naudojo atmintį per tiek laiko: {time}}many{# programos naudojo atmintį per tiek laiko: {time}}other{# programų naudojo atmintį per tiek laiko: {time}}}"</string>
    <string name="force_enable_pss_profiling_title" msgid="2253816522775341523">"Įgalinti atminties sąnaudų profiliavimą"</string>
    <string name="force_enable_pss_profiling_summary" msgid="7714294324548399136">"Norint profiliuoti atminties sąnaudas reikia papildomų sistemos išteklių."</string>
    <string name="pss_profiling_disabled" msgid="1967278421143514850">"Atminties profiliavimas išjungtas"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Dažnis"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Daugiausia panaudota"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Duomenys nenaudojami"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Leisti programos „<xliff:g id="APP">%1$s</xliff:g>“ prieigą prie „Do Not Disturb“?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Programa galės įjungti / išjungti prieigą prie „Do Not Disturb“ ir keisti susijusius nustatymus."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Turi būti įjungta, nes įjungta prieiga prie pranešimų"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Anuliuoti programos „<xliff:g id="APP">%1$s</xliff:g>“ galimybę pasiekti netrukdymo režimą?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Visos šios programos sukurtos netrukdymo režimo taisyklės bus pašalintos."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Neoptimizuoti"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimizuoti"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Akumuliatorius gali būti išeikvotas greičiau. Fone veikiančiai programai bus leidžiama naudoti akumuliatoriaus energiją."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Rekomenduojama, kad akumuliatoriaus veikimo laikas būtų ilgesnis"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Nėra"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Išjungus šios programos galimybę pasiekti naudojimo duomenis neišjungiama administratoriaus galimybė stebėti duomenų naudojimą darbo profilio programose."</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Rodoma virš kitų programų"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Rodyti virš kitų programų"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Leisti rodyti virš kitų programų"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Leisti šią programą pateikti virš kitų naudojamų programų. Ši programa galės peržiūrėti, kur paliečiate, arba keisti, kas pateikiama ekrane."</string>
    <string name="media_routing_control_title" msgid="6402800638960066807">"Keisti medijos išvestį"</string>
    <string name="allow_media_routing_control" msgid="4907036637509360616">"Leisti programai perjungti medijos išvestį"</string>
    <string name="allow_media_routing_description" msgid="8343709701298051207">"Leisti šiai programai pasirinkti, kuris prijungtas įrenginys leidžia garso ar vaizdo įrašą iš kitų programų. Jei leidžiama, ši programa gali pasiekti pasiekiamų įrenginių, pvz., ausinių ir garsiakalbių, sąrašą ir pasirinkti, kuris išvesties įrenginys naudojamas garso ar vaizdo įrašo srautui leisti ar įrašui perduoti."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Visų failų prieiga"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Leisti pasiekti ir tvarkyti visus failus"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Šiai programai leidžiama nuskaityti, keisti ir ištrinti visus failus, esančius šiame įrenginyje ar bet kurioje prijungtoje saugykloje. Jei suteiksite leidimą, programa gali pasiekti failus jūsų tiksliai neinformavus."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Gali pasiekti visus failus"</string>
    <string name="voice_activation_apps_title" msgid="7130045161611529825">"Suaktyvinimo balsu programos"</string>
    <string name="permit_voice_activation_apps" msgid="9152780172988949319">"Leisti suaktyvinimą balsu"</string>
    <string name="allow_voice_activation_apps_description" msgid="6369745626995060656">"Aktyvinimo balsu funkcija įjungia patvirtintas programas laisvų rankų režimu naudodama komandą balsu. Integruota prisitaikančio aptikimo funkcija užtikrina, kad duomenis matytumėte tik jūs.\n\n"<a href="">"Daugiau apie apsaugotą prisitaikantį aptikimą"</a></string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Pranešimai viso ekrano režimu"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Leisti pranešimus viso ekrano režimu iš šios programos"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Leiskite šiai programai rodyti pranešimus viso ekrano režimu, kai įrenginys užrakintas. Programos gali juos naudoti, kad paryškintų įspėjimus, gaunamuosius skambučius ar kitus skubius pranešimus."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Medijos valdymo programos"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Leisti programai valdyti mediją"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Leidus ši programa galės keisti arba ištrinti kitomis programomis sukurtus medijos failus be jūsų sutikimo. Programai turi būti suteiktas leidimas pasiekti failus ir mediją."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"medija, failas, valdymas, valdytojas, valdyti, redaguoti, redagavimo priemonė, programa, programėlė"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr virtualiosios realybės apdorojimo priemonė stereofoninis garsas pagalbinė paslauga"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Rodyti virš kitų programų"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Leidimą turinčios programos"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Leidžiama"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Neleidžiama"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"programų diegimas iš nežinomų šaltinių"</string>
    <string name="write_settings" msgid="6864794401614425894">"Keisti sistemos nustatymus"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"rašyti ir keisti sistemos nustatymus"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Galima įdiegti kitas programas"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Gali keisti sistemos nustatymus"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Gali keisti sistemos nustatymus"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Keisti sistemos nustatymus"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Leisti keisti sistemos nustatymus"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Programai bus leidžiama keisti sistemos nustatymus."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Leisti iš šio šaltinio"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Dukart pasukti, kad fotoap. pr. būtų at."</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Atidarykite fotoaparato programą dukart pasukę riešą"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Pateikties dydis"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Visų elementų padidinimas arba sumažinimas"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"ekrano tankis, ekrano mastelio keitimas, mastelis, mastelio nustatymas"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Peržiūra"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Padaryti mažesnius"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Padaryti didesnius"</string>
    <string name="disconnected" msgid="3469373726996129247">"Neprisijungta"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Neprijungta"</string>
    <string name="apps_summary" msgid="4007416751775414252">"Įdiegtų programų: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="storage_summary" msgid="5903562203143572768">"Naudojama: <xliff:g id="PERCENTAGE">%1$s</xliff:g>, laisvos vietos: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tamsioji tema, šrifto dydis, šviesumas"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Vid. naudojama atminties: <xliff:g id="USED_MEMORY">%1$s</xliff:g> iš <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="8473589474976307510">"Prisijungta kaip <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Atnaujinta į <xliff:g id="VERSION">%1$s</xliff:g> versijos „Android“"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Pasiekiamas naujinys"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Užblokuota vadovaujantis darbo politika"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Nepavyko pakeisti garsumo"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Nepavyksta skambinti"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Nepavyksta išsiųsti SMS pranešimų"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Nepavyksta naudoti fotoaparato"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Nepavyksta padaryti ekrano kopijų"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Nepavyko atidaryti šios programos"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Užblokavo kredito kortelės teikėjas"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Reikalingas vienas iš tėvų"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Perduokite telefoną vienam iš tėvų, kad būtų pradėta sąranka"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Perduokite telefoną vienam iš tėvų, kad būtų galima pakeisti šį nustatymą."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Jei reikia daugiau informacijos, susisiekite su IT administratoriumi"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Daugiau išsamios informacijos"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Administratorius gali stebėti ir tvarkyti su jūsų darbo profiliu susietas programas ir duomenis, įskaitant nustatymus, leidimus, prieigą prie įmonės duomenų, tinklo veiklą ir įrenginio vietovės informaciją."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Administratorius gali stebėti ir tvarkyti su šiuo naudotoju susietas programas ir duomenis, įskaitant nustatymus, leidimus, prieigą prie įmonės duomenų, tinklo veiklą ir įrenginio vietovės informaciją."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Administratorius gali stebėti ir tvarkyti programas ir duomenis, susijusius su šiuo įrenginiu, įskaitant nustatymus, leidimus, prieigą prie įmonės duomenų, tinklo veiklą ir įrenginio vietovės informaciją."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Įrenginio administratorius gali pasiekti duomenis, susietus su šiuo įrenginiu, tvarkyti programas ir pakeisti šio įrenginio nustatymus."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Išjungti"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Įjungti"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Rodyti"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Slėpti"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Vieš. int. prieig. tašk. akt."</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Įjungtas lėktuvo režimas"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Tinklai nepasiekiami"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Netrukdymo režimas įjungtas"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Telefonas nutildytas"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Su išimtimis"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Akumul. tausoj. priem. įjungta"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Apribotos funkcijos"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobiliojo ryšio duom. išjungti"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internetas pasiekiamas tik naudojant „Wi‑Fi“ ryšį"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Duomenų taupymo priemonė"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Apribotos funkcijos"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Darbo profilis išjungtas"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Programoms ir pranešimams"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Įjungti garsą"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Skambutis nutildytas"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Skambučiams ir pranešimams"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Tik vibruoti"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Skambučiai ir pranešimai"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Nakties šviesos tvarkaraščio nustatymas"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Automatiškai suteikti atspalvį ekranui kiekvieną vakarą"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Nakties šviesa įjungta"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Ekrano atspalvis pakeistas į gelsvą"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Pilkumo tonas"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Pateikiama tik pilkos spalvos"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Sutraukti"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Šaltų spalvų temperatūra"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Naudoti šaltesnes ekrano spalvas"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Kad pritaikytumėte spalvos pakeitimą, išjunkite ekraną"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Fotoaparato lazerio jutiklis"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatiniai sistemos naujiniai"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Atnaujinimai pritaikomi, kai įrenginys paleidžiamas iš naujo"</string>
    <string name="usage" msgid="287782903846013936">"Naudojimas"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Mobiliojo ryšio duom. naud."</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Programos duomenų naudojimas"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"„Wi-Fi“ duomenų naudojimas"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Ne operatoriaus duomenų naudojimas"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Eterneto duomenų naudojimas"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Eternetas"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> mobiliojo ryšio duomenų"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> „Wi-Fi“ duomenų"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> eterneto duomenų"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Įspėjimas dėl duomenų ir riba"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Mobiliojo ryšio duomenų naudojimo ciklas"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"<xliff:g id="ID_1">^1</xliff:g> duomenų įspėjimas"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"<xliff:g id="ID_1">^1</xliff:g> duomenų apribojimas"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"<xliff:g id="ID_1">^1</xliff:g> duomenų įspėjimas / <xliff:g id="ID_2">^2</xliff:g> duomenų apribojimas"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Išskiriami duomenys, kuriuos naudoja operatorių tinklai"</string>
    <string name="data_used_template" msgid="8229342096562327646">"Išnaudota <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Nustatyti duomenų įspėjimą"</string>
    <string name="data_warning" msgid="2925054658166062884">"Duomenų įspėjimas"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Jūsų įrenginys nustato duomenų įspėjimą ir duomenų apribojimą. Tai gali skirtis nuo operatoriaus duomenų."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Nustatyti duomenų apribojimą"</string>
    <string name="data_limit" msgid="8731731657513652363">"Duomenų apribojimas"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_2">%2$s</xliff:g> sunaudota: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Konfigūruoti"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Kitos įtrauktos naudojamos programos"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{Vienai programai leidžiama naudoti neribotus duomenis, kai įjungta Duomenų taupymo priemonė}one{# programai leidžiama naudoti neribotus duomenis, kai įjungta Duomenų taupymo priemonė}few{# programoms leidžiama naudoti neribotus duomenis, kai įjungta Duomenų taupymo priemonė}many{# programos leidžiama naudoti neribotus duomenis, kai įjungta Duomenų taupymo priemonė}other{# programų leidžiama naudoti neribotus duomenis, kai įjungta Duomenų taupymo priemonė}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Pagrindiniai duomenys"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"„Wi‑Fi“ duomenys"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Išnaudota: <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Viršyta <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Liko: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Diagramoje rodomas duomenų naudojimas <xliff:g id="START_DATE">%1$s</xliff:g>–<xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Šią dienų seką atitinkančių duomenų nėra"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{Liko # diena}one{Liko # diena}few{Liko # dienos}many{Liko # dienos}other{Liko # dienų}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Laiko neliko"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Liko mažiau nei 1 diena"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Prieš <xliff:g id="ID_2">^2</xliff:g> atnaujino „<xliff:g id="ID_1">^1</xliff:g>“"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Atnaujinta prieš <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Ką tik atnaujino „<xliff:g id="ID_1">^1</xliff:g>“"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Ką tik atnaujinta"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Žr. išsamią informaciją"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Duom. taupymo priem."</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Neriboti duomenys"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Foniniai duomenys išjungti"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Įjungta"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Išjungta"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Naudoti duomenų taupymo priemonę"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Neribotų duomenų naudojimas"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Leisti pas. nerib. duom., kai Duom. t. pr. įj."</string>
    <string name="home_app" msgid="6056850504746902747">"Pagrindinio puslapio programa"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Pridėkite kitą piršto antspaudą"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Atrakinkite naudodami kitą pirštą"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Įjungta"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Bus įjungta pasiekus <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Išjungta"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Programos akumuliatoriaus energijos vartojimas"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Nustatyti programų akumuliatoriaus energijos vartojimą"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Peržiūrėti nustatymus"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Tikrinti"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"Supratau"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Ar šis pranešimas naudingas?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Akumuliatoriaus patarimų perspėjimo piktograma"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Įjunkite prisitaikantį šviesumą, kad pailgintumėte akumuliatoriaus veikimo laiką"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Sumažinkite ekrano skirtąjį laiką, kad pailgintumėte akumuliatoriaus veikimo laiką"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"Programa „<xliff:g id="APP_LABEL">%1$s</xliff:g>“ naudojo daugiau akumuliatoriaus energijos"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"Programa „<xliff:g id="APP_LABEL">%1$s</xliff:g>“ naudojo daugiau akumuliatoriaus energijos nei įprastai"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"Programa „<xliff:g id="APP_LABEL">%1$s</xliff:g>“ naudojo daugiau akumuliatoriaus energijos veikdama fone"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"Programa „<xliff:g id="APP_LABEL">%1$s</xliff:g>“ naudojo daugiau akumuliatoriaus energijos nei įprastai veikdama fone"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"Programa „<xliff:g id="APP_LABEL">%1$s</xliff:g>“ naudojo daugiau akumuliatoriaus energijos veikdama priekiniame plane"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"Programa „<xliff:g id="APP_LABEL">%1$s</xliff:g>“ naudojo daugiau akumuliatoriaus energijos nei įprastai veikdama priekiniame plane"</string>
    <string name="battery_usage_anomaly_content_description" msgid="3199380151630770476">"Akumuliatoriaus energijos vartojimo nukrypimas"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"Didelis akumuliatoriaus energijos vartojimas"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"Didelis akumuliatoriaus energijos vartojimas fone"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"Didelis akumuliatoriaus energijos vartojimas priekiniame plane"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Neapribota"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimizuota"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Apribota"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Numatytasis rašybos tikrinimas"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Rašybos tikrinimo pasirinkimas"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Naudoti rašybos tikrinimą"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Nepasirinkta"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pkg"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"raktas"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"grupė"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(suvestinė)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"vieša versija"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"svarba"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"paaiškinimas"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"gali rodyti ženklelį"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"tikslas"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"ištrinti tikslą"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"viso ekrano tikslas"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"veiksmai"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"pavadinimas"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"nuotolinio valdymo įvestys"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"tinkintas rodinys"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"priedai"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"piktograma"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"dydis"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"pateiktas įspėjimas apie pranešimą"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanalas"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Trūksta reitingavimo objekto."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Reitingavimo objekte nėra šio rakto."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Ekrano išpjova"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"ekrano išpjova, įranta"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Numatytasis įrenginio nustatymas"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Nepavyko pritaikyti perdangos"</string>
    <string name="special_access" msgid="1767980727423395147">"Spec. prieiga prie prog."</string>
    <string name="special_access_more" msgid="132919514147475846">"Žr. daugiau"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Ilgai trunkančios užduotys fone"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Leisti ilgai trunkančias užduotis fone"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Ilgai trunkančios užduotys fone"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Leidžiama šiai programai atlikti ilgai trunkančias užduotis fone. Programa gali vykdyti užduotis, kurios gali trukti ilgiau nei kelias minutes, pvz., atsisiuntimai ir įkėlimai. \n\nAtmetus šį leidimą sistema apribos, kiek laiko programa gali vykdyti tokias užduotis fone."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"ilgai trunkantys darbai, duomenų perkėlimas, fone atliekamos užduotys"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Iš naujo nustatyti „ShortcutManager“ įkainių ribojimą"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"„ShortcutManager“ įkainių ribojimas nustatytas iš naujo"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Valdykite informaciją užrakinimo ekrane"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Rodykite arba slėpkite pranešimo turinį"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Patarimai ir palaikymas"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Mažiausias plotis"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Nėra jokių įdiegtų programų, pateikusių išskirtinių SMS prieigos užklausą"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Išskirtiniai SMS gali būti mokami ir į operatoriaus sąskaitas gali būti įtraukta papildomų mokesčių. Jei įgalinsite programos leidimą, galėsite siųsti išskirtinius SMS naudodami tą programą."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Išskirtinių SMS prieiga"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Išjungta"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Prisijungta prie „<xliff:g id="ID_1">%1$s</xliff:g>“"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Prisijungta prie kelių įrenginių"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Sistemos NS demonstracinis režimas"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tamsioji tema"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Laikinai išjungta dėl Akumuliatoriaus tausojimo priemonės"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Laikinai išjungta dėl Akumuliatoriaus tausojimo priemonės"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Išjungti Akumuliatoriaus tausojimo priemonę"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Laikinai išjungta dėl akumuliatoriaus tausojimo priemonės"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Išbandyti tamsiąją temą"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Pailginamas akumuliatoriaus veikimo laikas"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Sparčiųjų nustatymų kūrėjo išklotinės elementai"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"ADB prieigos teisės skirtojo laiko išjungimas"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Išjungti automatinį ADB prieigos teisės anuliavimą sistemose, kurios nebuvo iš naujo prijungtos per numatytą (7 dienų) arba naudotojo sukonfigūruotą (mažiausiai 1 dienos) laikotarpį."</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Jutikliai išjungti"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Darbo profilio nustatymai"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Ieškoti darbo katalogo kontaktų naudojant asmenines programas"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"IT administratorius gali matyti jūsų paieškas ir gaunamuosius skambučius"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kelių profilių kalendorius"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Rodyti darbo įvykius asmeniniame kalendoriuje"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Kai darbo programos išjungtos, jos yra pristabdytos ir jų negalima pasiekti ar siųsti joms pranešimų"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Tvarkyti saugyklą"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Kad padėtų atlaisvinti saugyklos vietos, saugyklos tvarkytuvė iš įrenginio pašalina nuotraukas ir vaizdo įrašus, kurių atsarginė kopija sukurta."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Pašalinti nuotraukas ir vaizdo įrašus"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Saugyklos tvarkytuvė"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Naudoti Saugyklos tvarkytuvę"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gestai"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Spartusis fotoaparato atidarymas"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Jei norite greitai atidaryti fotoaparatą, dukart paspauskite maitinimo mygtuką. Veikia bet kuriame ekrane."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Fotoaparato apvertimas fiksuojant asmenukę"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Naršymo režimas"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Naršymas 2 mygtukais"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Jei norite perjungti programas, perbraukite aukštyn pagrindinio ekrano mygtuku. Jei norite peržiūrėti visas programas, perbraukite aukštyn dar kartą. Jei norite grįžti, palieskite grįžimo mygtuką."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Sauga ir kritinė padėtis"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Pagalbos iškvietimas kritiniu atveju, medicininė informacija, įspėjimai"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Naršymas gestais"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"Jei norite eiti į pagrindinį ekraną, perbraukite aukštyn nuo ekrano apačios. Jei norite perjungti programas, perbraukite aukštyn nuo apačios, palaikykite ir atleiskite. Jei norite grįžti, perbraukite nuo kairiojo arba dešiniojo krašto."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Naršymas 3 mygtukais"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Grįžkite, eikite į pagrindinį ekraną ir perjunkite programas naudodami ekrano apačioje esančius mygtukus."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"sistemos naršymas, naršymas 2 mygtukais, naršymas 3 mygtukais, naršymas gestais, perbraukti"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Skaitmeninis pagelbiklis"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Pagelbiklio iškvietimas perbraukus"</string>
    <string name="assistant_corner_gesture_summary" msgid="5012534700233017955">"Perbraukite aukštyn iš apatinio kampo, kad iškviestumėte skaitmeninio pagelbiklio programą"</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Padėjėjo iškvietimas paspaudus pagrindinio ekrano mygtuką"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Jei norite iškviesti skaitmeninio pagelbiklio programą, paspauskite ir palaikykite pagrindinio ekrano mygtuką."</string>
    <string name="low_label" msgid="6525629096999711220">"Mažas"</string>
    <string name="high_label" msgid="357503396626018487">"Didelis"</string>
    <string name="left_edge" msgid="1513576842959071849">"Kairysis kraštas"</string>
    <string name="right_edge" msgid="1505309103265829121">"Dešinysis kraštas"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Didesnis jautrumas gali būti nesuderinamas su visais programų gestais palei ekrano kraštus."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Grįžtamasis jautrumas"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Naršymo gestais jautrumas"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Naršymas mygtukais"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"naršymas gestais, grįžtamasis jautrumas, grįžtamasis gestas"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"naršymas, pagrindinio puslapio mygtukas"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Vienos rankos režimas"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Naudoti vienos rankos režimą"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Vienos rankos režimo spartusis klavišas"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"pasiekiamumas"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Perbraukimas žemyn"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Naudokite spartųjį klavišą, norėdami"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Patraukite viršutinę ekrano dalį žemyn, kad būtų lengviau pasiekti viena ranka"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Kaip naudoti vienos rankos režimą"</b>\n" • Įsitikinkite, kad sistemos naršymo nustatymuose pasirinktas naršymas gestais\n • Perbraukite žemyn šalia apatinio ekrano krašto"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Ekrano patraukimas, kad jis taptų pasiekiamas"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Ekrano viršus bus perkeltas, kad jį būtų galima pasiekti nykščiu."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Pranešimų rodymas"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Bus rodomi pranešimai ir nustatymai."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Norėdami sužinoti laiką, peržiūrėti pranešimus ir kitą informaciją, dukart palieskite ekraną."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Pažadinti ekraną"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Norėdami sužinoti laiką, peržiūrėti pranešimus ir kitą informaciją, palieskite ekraną."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Pagalbos iškvietimas kritiniu atveju"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Naudoti pagalbos iškvietimo kritiniu atveju paslaugą"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Penkis ar daugiau kartų greitai paspauskite maitinimo mygtuką, kad būtų pradėti vykdyti toliau nurodyti veiksmai"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Paleisti atvirkštinio skaičiavimo signalą"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Leisti skambų garsą, kai pradedama kviesti pagalba kritiniu atveju"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Praneškite, jei reikia pagalbos"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Skambinimas dėl pagalbos"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Numeris, kuriuo skambinti prireikus pagalbos"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Palieskite, kad pakeistumėte"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Jei įvedate ne pagalbos numerį:\n • jūsų įrenginys turi būti atrakintas, kad būtų galima iškviesti pagalbą kritiniu atveju;\n • į jūsų skambutį gali būti neatsiliepta."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Perbraukimas piršto antspaudo jutikliu norint peržiūrėti pranešimus"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Perbr. kontr. k. jutikliu"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Greitai peržiūrėkite pranešimus"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Įjungta"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Išjungta"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Paleidyklė jau atrakinta"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Prisijunkite prie interneto arba susisiekite su operatoriumi"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Nepasiekiamas įrenginiuose, kuriuose taik. operat. pasirink. ribojimas"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Norėdami įgalinti įrenginio apsaugos funkciją, paleiskite įrenginį iš naujo."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Iš viso pasiekiama: <xliff:g id="SIZE">%1$s</xliff:g>\n\nPaskutinį kartą vykdyta <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Akimirksniu įkeliamos programos"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Atidaryti nuorodas programose, net jei jos neįdiegtos"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Akimirksniu įkeliamos programos"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"„Android“ akimirksniu įkeliamų programų nuostatos"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Įdiegtos programos"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Saugyklą dabar tvarko saugyklos valdytojas"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"<xliff:g id="USER_NAME">%1$s</xliff:g> paskyros"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Automatiškai sinchronizuoti programų duomenis"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Leisti programoms automatiškai atnaujinti duomenis"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Paskyros sinchronizav."</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Įjungtas elementų sinchronizavimas: <xliff:g id="ID_1">%1$d</xliff:g> iš <xliff:g id="ID_2">%2$d</xliff:g>"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Įjungtas visų elementų sinchronizavimas"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Išjungtas visų elementų sinchronizavimas"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Tvarkoma įrenginio informacija"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Pakeitimus ir nustatymus tvarko jūsų organizacija"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Pakeitimus ir nustatymus tvarko „<xliff:g id="ORGANIZATION_NAME">%s</xliff:g>“"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Norėdama suteikti prieigą prie jūsų darbo duomenų, organizacija gali pakeisti nustatymus ir įdiegti programinę įrangą jūsų įrenginyje.\n\nJei reikia daugiau išsamios informacijos, susisiekite su organizacijos administratoriumi."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Informacijos, kurią gali matyti jūsų organizacija, tipai"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Jūsų organizacijos administratoriaus atlikti pakeitimai"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Prieiga prie šio įrenginio"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Su darbo paskyra susiję duomenys, pvz., el. pašto ir kalendoriaus"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Programų jūsų įrenginyje sąrašas"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Kiekvienoje programoje praleistas laikas ir sunaudotų duomenų kiekis"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Naujausias tinklo srauto žurnalas"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Pats naujausias pranešimas apie riktą"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Pats naujausias saugos žurnalas"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Nėra"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Programos įdiegtos"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Numatomas programų skaičius. Jis gali neapimti už „Play“ parduotuvės ribų įdiegtų programų."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Mažiausiai # programa}one{Mažiausiai # programa}few{Mažiausiai # programos}many{Mažiausiai # programos}other{Mažiausiai # programų}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Leidimas pasiekti vietovės duomenis"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Mikrofono leidimai"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Fotoaparato leidimai"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Numatytosios programos"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# programa}one{# programa}few{# programos}many{# programos}other{# programų}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Numatytoji klaviatūra"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Nustatyti į „<xliff:g id="APP_LABEL">%s</xliff:g>“"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Visada įjungto VPN funkcija įjungta"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Visada įjungto VPN funkcija įjungta jūsų asmeniniame profilyje"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Visada įjungto VPN funkcija įjungta jūsų darbo profilyje"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Nustatytas visuotinis HTTP tarpinis serveris"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Patikimi prisijungimo duomenys"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Patikimi prisijungimo duomenys asmeniniame profilyje"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Patikimi prisijungimo duomenys darbo profilyje"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Mažiausiai # CA sertifikatas}one{Mažiausiai # CA sertifikatas}few{Mažiausiai # CA sertifikatai}many{Mažiausiai # CA sertifikato}other{Mažiausiai # CA sertifikatų}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Administratorius gali užrakinti įrenginį ir iš naujo nustatyti slaptažodį"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administratorius gali ištrinti visus įrenginio duomenis"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Nesėkmingų bandymų įvesti slaptažodį skaičius prieš ištrinant visus įrenginio duomenis"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Nesėkmingų bandymų įvesti slaptažodį skaičius prieš ištrinant darbo profilio duomenis"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# bandymas}one{# bandymas}few{# bandymai}many{# bandymo}other{# bandymų}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Šį įrenginį tvarko jūsų organizacija."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Šį įrenginį tvarko „<xliff:g id="ORGANIZATION_NAME">%s</xliff:g>“."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Sužinoti daugiau"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Apribotas nustatymas"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Apriboti nustatymai leidžiami programoje „<xliff:g id="APP_NAME">%s</xliff:g>“"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Šis nustatymas šiuo metu nepasiekiamas dėl jūsų saugumo."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Finansuojamo įrenginio informacija"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Jūsų kredito teikėjas gali pakeisti nustatymus ir įdiegti programinę įrangą šiame įrenginyje vykdant sąrankos procesą.\n\nJei praleisite mokėjimą, kredito teikėjas gali užrakinti įrenginį ir pakeisti įrenginio nustatymus.\n\nJei norite sužinoti daugiau, susisiekite su kredito teikėju."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Jei įrenginys finansuojamas, negalite atlikti nurodytų veiksmų."</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Įdiegti programas ne iš „Play“ parduotuvės"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Paleisti įrenginį iš naujo saugos režimu"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Pridėti kelis naudotojus prie įrenginio"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Keisti datą, laiką ir laiko juostas"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Naudoti kūrėjo parinktis"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Kredito teikėjas gali atlikti nurodytus veiksmus."</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Pasiekti IMEI numerį"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Atkurkite gamyklinius įrenginio nustatymus, jei kas nors neveikia"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Jei įrenginys bus užrakintas, juo galėsite atlikti tik nurodytus veiksmus."</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Skambinti pagalbos numeriais"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Peržiūrėti sistemos informaciją, pvz., datą, laiką, tinklo būseną ir akumuliatoriaus informaciją"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Įjungti arba išjungti įrenginį"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Peržiūrėti įspėjimus ir teksto pranešimus"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Pasiekti programas, kurias leidžia kredito teikėjas"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Sumokėję visą sumą, galėsite atlikti nurodytus veiksmus."</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Visi apribojimai pašalinami iš įrenginio"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Galite pašalinti kreditoriaus programą"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Finansuojamo įrenginio informacija"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Fotoaparato programa}one{Fotoaparato programos}few{Fotoaparato programos}many{Fotoaparato programos}other{Fotoaparato programos}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Kalendoriaus programa"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Kontaktų programa"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{El. pašto programa}one{El. pašto programos}few{El. pašto programos}many{El. pašto programos}other{El. pašto programos}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Žemėlapių programa"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Telefono programa}one{Telefono programos}few{Telefono programos}many{Telefono programos}other{Telefono programos}}"</string>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"„<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>“, „<xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>“"</string>
    <string name="app_names_concatenation_template_3" msgid="7019703249717854148">"„<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>“, „<xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>“, „<xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>“"</string>
    <string name="storage_default_internal_storage" msgid="4055660218818688131">"Šis įrenginys"</string>
    <string name="storage_games" msgid="1176568610086802469">"Žaidimai"</string>
    <string name="storage_files" msgid="7968460921272772299">"Failai"</string>
    <string name="storage_images" msgid="2055893015567979387">"Vaizdai"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Vaizdo įrašai"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Garso įrašas"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Programos"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumentai ir kt."</string>
    <string name="storage_system" msgid="8472410119822911844">"Sistema"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Šiukšliadėžė"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Išvalyti šiukšliadėžę?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Šiukšliadėžėje yra <xliff:g id="TOTAL">%1$s</xliff:g> failų. Visi elementai bus visam laikui ištrinti ir negalėsite jų atkurti."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Šiukšliadėžė tuščia"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Išvalyti šiukšliadėžę"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"Išnaudota: <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Iš viso: <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Išvalyti programą"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Ar norite pašalinti šią akimirksniu įkeliamą programėlę?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Atidaryti"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Žaidimai"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Naudojama vieta"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(pašalinta naudotojui <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(išjungta naudotojui <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Aut. pildymo paslauga"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Numatytoji automatinio pildymo paslauga"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Slaptažodžiai"</string>
    <string name="credman_chosen_app_title" msgid="7735183808067729319">"Pageidaujama paslauga"</string>
    <string name="credman_credentials" msgid="2620352336624160642">"Papildomos paslaugos"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# slaptažodis}one{# slaptažodis}few{# slaptažodžiai}many{# slaptažodžio}other{# slaptažodžių}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automatinis, užpildyti, automatinis pildymas, slaptažodis"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"duomenys, „passkey“, slaptažodis"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"automatinis, užpildyti, automatinis pildymas, duomenys, prieigos raktas, slaptažodis"</string>
    <string name="credman_button_change" msgid="4072629639218503790">"Keisti"</string>
    <string name="credman_button_open" msgid="7519871964170816850">"Atidaryti"</string>
    <string name="credman_app_list_preference_none" msgid="2509646651254971448">"Nieko nepasirinkta"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Įsitikinkite, kad pasitikite šia programa&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=„Google“ automatinis pildymas&gt;%1$s&lt;/xliff:g&gt; naudodamas informaciją ekrane nustato, ką gali užpildyti automatiškai."</string>
    <string name="credman_autofill_confirmation_message" msgid="843829628024668466">"&lt;b&gt;Naudokite &lt;xliff:g id=app_name example=„Provider“&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Nuo šiol čia išsaugomi nauji slaptažodžiai, prieigos raktai ir kita informacija. &lt;xliff:g id=app_name example=„Provider“&gt;%1$s&lt;/xliff:g&gt; gali naudoti ekrane esančią informaciją, kad nustatytų, ką galima automatiškai užpildyti."</string>
    <string name="credman_picker_title" msgid="8442086614222006564">"Pageidaujama slaptažodžių, prieigos raktų ir automatinio pildymo paslauga"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Išjungti „%1$s“?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Išjungti šį įrenginį?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Išsaugota informacija, pvz., slaptažodžiai, prieigos raktai, mokėjimo metodai ir kita informacija, nebus užpildyta prisijungiant. Jei norite naudoti išsaugotą informaciją, pasirinkite slaptažodį, prieigos raktą arba duomenų paslaugą."</string>
    <string name="account_dashboard_title_with_passkeys" msgid="6214673787161409996">"Slaptažodžiai, prieigos raktai ir automatinis pildymas"</string>
    <string name="credman_confirmation_message_new_ui" msgid="6126274509951156460">"&lt;b&gt;Išjungti visas paslaugas?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Kai prisijungsite, slaptažodžių, prieigos raktų ir kitos informacijos nebus galima užpildyti automatiškai"</string>
    <string name="credman_autofill_confirmation_message_new_ui" msgid="6222139222478822267">"&lt;b&gt;Pakeiskite pageidaujamą paslaugą į &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Nuo dabar nauji slaptažodžiai, prieigos raktai ir kita informacija bus išsaugomi čia. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; gali naudoti ekrane esančią informaciją, kad nustatytų, ką galima automatiškai užpildyti"</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Naudoti „%1$s“?"</string>
    <string name="credman_confirmation_turn_off_positive_button" msgid="5678773011513369161">"Išjungti"</string>
    <string name="credman_confirmation_change_provider_positive_button" msgid="7732302992885116967">"Keisti"</string>
    <string name="credman_limit_error_msg_title" msgid="1525814645803612135">"Gali būti įjungtos tik penkios paslaugos"</string>
    <string name="credman_limit_error_msg" msgid="2521803280130310063">"Išjunkite bent vieną paslaugą, kad galėtumėte pridėti kitą"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"„%1$s“ naudoja ekrane esančią informaciją siekdama nustatyti, ką galima automatiškai užpildyti."</string>
    <string name="credman_error_message_title" msgid="4099557206946333568">"Slaptažodžių, prieigos raktų ir duomenų paslaugų apribojimas"</string>
    <string name="credman_error_message" msgid="8334797097200415449">"Vienu metu galite turėti daugiausia penkis aktyvius slaptažodžius, prieigos raktus ir duomenų paslaugas. Norėdami pridėti daugiau, išjunkite paslaugą."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Išjungti"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Automatinis pildymas"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Registr. į žurnalą lygis"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Didžiausias užklausų skaičius per sesiją"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Maks. matomų duomenų rinkinių"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Nustatyti numatytąsias vertes iš naujo"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Automatinio pildymo kūrėjo parinktys nustatytos iš naujo"</string>
    <string name="location_category" msgid="3496759112306219062">"Vieta"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Būsenos juostos vietos indikatorius"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Rodyti visoms vietoms, įskaitant tinklą ir ryšį"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Priversti vykdyti visus GNSS matavimus"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Stebėti visas GNSS konferencijas ir visus dažnius netaikant darbo ciklų"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Įvesties metodas"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Rašymas rašikliu"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Kai įjungta, dabartinis įvesties metodas gauna rašiklio judesio įvykį, jei redagavimo priemonė sufokusuota."</string>
    <string name="device_theme" msgid="5027604586494772471">"Įrenginio tema"</string>
    <string name="default_theme" msgid="4815428567082263639">"Numatytoji"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Tinklo pavadinimas"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Rodyti tinklo pavadinimą būsenos juostoje"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Akimirksniu įkeliama programėlė"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Išjungti saugyklos tvarkytuvę?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Atnaujinti netrukdymo režimą"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pristabdyti pranešimus, kad neblaškytų dėmesio"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funkcija negalima"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Ši funkcija buvo išjungta, nes, kai ji įjungta, telefonas veikia lėčiau"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Visada rodyti strigčių dialogo langą"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Rodyti dialogo langą kiekvieną kartą, kai programa užstringa"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Pasirinkti programą, kurioje įgalinta ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Nėra jokių programų, kuriose būtų įgalinta ANGLE, rinkinių"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Programa, kurioje įgalinta ANGLE: „<xliff:g id="APP_NAME">%1$s</xliff:g>“"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Grafikos tvarkyklės nuostatos"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Keiskite grafikos tvarkyklės nustatymus"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Kai yra kelios grafikos tvarkyklės, galite pasirinkti naudoti atnaujintą grafikos tvarkyklę, skitą įrenginyje įdiegtoms programoms."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Įgalinimas visose programose"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Grafikos tvarkyklės pasirinkimas"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Numatytasis"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Žaidimų tvarkyklė"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Kūrėjo tvarkyklė"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Sistemos grafikos tvarkyklė"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="enable_angle_as_system_driver" msgid="4648827560023949786">"Eksperimentas: ANGLE įgalinimas"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Perspėjimas: įgalinkite ANGLE kaip numatytąją „OpenGL ES“ tvarkyklę. Ši funkcija yra eksperimentinė ir gali būti nesuderinama su kai kuriomis fotoaparato ir vaizdo įrašų programomis."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Norint pakeisti sistemos „OpenGL ES“ tvarkyklę, būtina paleisti iš naujo"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Programos suderinamumo pakeitimai"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Perjungti programos suderinamumo pakeitimus"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Numatytieji įgalinti pakeitimai"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Numatytieji išjungti pakeitimai"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Galima keisti tik derinamų programų suderinamumą. Įdiekite derinamą programą ir bandykite dar kartą."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Priklauso nuo kito nustatymo"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Paskyra"</string>
    <string name="my_device_info_account_preference_summary" msgid="3510582677937510545">"Paskyrų: %d"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Įrenginio pavadinimas"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Pagrindinė informacija"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Teisės aktai ir reglamentai"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Išsami įrenginio informacija"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Įrenginių identifikatoriai"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"„Wi-Fi“ valdymas"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Leisti programai valdyti „Wi-Fi“"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Leiskite šiai programai įjungti arba išjungti „Wi-Fi“, nuskaityti „Wi-Fi“ tinklus ir prisijungti prie jų, pridėti ar pašalinti tinklus arba paleisti tik vietinį viešosios interneto prieigos tašką"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Paleisti per NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Leisti paleisti nuskaitant NFC"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Leisti paleisti šią programą, kai nuskaitoma NFC žyma.\nJei šis leidimas įjungtas, programa bus pasiekiama kaip parinktis, kai žyma bus aptikta."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Leisti mediją į"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Paleisti: <xliff:g id="LABEL">%s</xliff:g>"</string>
    <string name="media_output_title_without_playing" msgid="3339321669132875821">"Garsas bus leidžiamas"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Šis įrenginys"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Nepasiekiama skambučių metu"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Gauti skambučius"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Negalima pakeisti šio APN."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Skambėjimo išjungimas"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Kartu paspauskite maitinimo ir garsumo padidinimo mygtukus"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Spartusis klavišas, naudojamas siekiant išvengti skambėjimo"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibruoti"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Nutildyti"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibruoti"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Nutildyti"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Jei norite įgalinti, pirmiausia pakeiskite veiksmą „Paspausti ir palaikyti maitinimo mygtuką“ į įjungimo meniu."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Išsami tinklo info."</string>
    <string name="devices_title" msgid="649715719278562515">"Įrenginiai"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Pasirinkti tinklą"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Atsijungta"</string>
    <string name="network_connected" msgid="7637745547242487795">"Prisijungta"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Prisijungiama…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Nepavyko prisijungti"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Nerasta jokių tinklų."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Nepavyko rasti tinklų. Bandykite dar kartą."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(uždrausta)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Nėra SIM kortelės"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Nėra"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Kad būtų galima prisijungti, reikia SIM kortelės"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Kad būtų galima prisijungti, reikia „<xliff:g id="WIRELESS_CARRIER">%s</xliff:g>“ SIM kortelės"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Pageidaujamas tinklo režimas: pageidautina WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Pageidaujamas tinklo režimas: tik GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Pageidaujamas tinklo režimas: tik WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Pageidaujamas tinklo režimas: CDMA / WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Pageidaujamas tinklo režimas: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Pageidaujamas tinklo režimas: CDMA / „EvDo“"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Pageidaujamas tinklo režimas: tik CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Pageidaujamas tinklo režimas: tik „EvDo“"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Pageidaujamas tinklo režimas: CDMA / „EvDo“ / GSM / WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Pageidaujamas tinklo režimas: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Pageidaujamas tinklo režimas: GSM / WCDMA / LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Pageidaujamas tinklo režimas: CDMA ir LTE / EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Pageidaujamas tinklo režimas: LTE / CDMA / „EvDo“ / GSM / WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Pageidaujamas tinklo režimas: pasaulinis"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Pageidaujamas tinklo režimas: LTE / WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Pageidautinas tinklo režimas: LTE / GSM / UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Pageidaujamas tinklo režimas: LTE / CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Pageidaujamas tinklo režimas: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Pageidaujamas tinklo režimas: TDSCDMA / WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Pageidaujamas tinklo režimas: LTE / TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Pageidaujamas tinklo režimas: TDSCDMA / GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Pageidaujamas tinklo režimas: LTE / GSM / TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Pageidaujamas tinklo režimas: TDSCDMA / GSM / WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Pageidaujamas tinklo režimas: LTE / TDSCDMA / WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Pageidaujamas tinklo režimas: LTE / TDSCDMA / GSM / WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Pageidaujamas tinklo režimas: TDSCDMA / CDMA / „EvDo“ / GSM / WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Pageidaujamas tinklo režimas: LTE / TDSCDMA / CDMA / „EvDo“ / GSM / WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Pageidaujamas tinklo režimas: tik NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Pageidaujamas tinklo režimas: NR / LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Pageidaujamas tinklo režimas: NR / LTE / CDMA / „EvDo“"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Pageidaujamas tinklo režimas: NR / LTE / GSM / WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Pageidaujamas tinklo režimas: NR / LTE / CDMA / „EvDo“ / GSM / WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Pageidaujamas tinklo režimas: NR / LTE / WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Pageidaujamas tinklo režimas: NR / LTE / TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Pageidaujamas tinklo režimas: NR / LTE / TDSCDMA / GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Pageidaujamas tinklo režimas: NR / LTE / TDSCDMA / WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Pageidaujamas tinklo režimas: NR / LTE / TDSCDMA / GSM / WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Pageidaujamas tinklo režimas: NR / LTE / TDSCDMA / CDMA / „EvDo“ / GSM / WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (rekomenduojama)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (rekomenduojama)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (rekomenduojama)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Automatiškai pasirinkti tinklą"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Operatoriaus nustatymai"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Nustatyti duomenų paslaugą"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobilieji duomenys"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Prieiga prie duomenų naudojant mobiliojo ryšio tinklą"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefone bus automatiškai perjungtos šio operatoriaus paslaugos, kai bus pasiekiamos"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Pasiekiamų SIM kortelių nėra"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Skambučių nuostata"</string>
    <string name="sms_preference" msgid="7742964962568219351">"SMS nuostata"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Klausti kaskart"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Pridėti tinklą"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Numatytoji skambučių SIM kortelė"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Numatytoji SMS pranešimų SIM kortelė"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Numatytoji SMS ir skambučių SIM kortelė"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Numatytoji mobiliųjų duomenų SIM kortelė"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobiliojo ryšio duomenys įjungti"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobiliojo ryšio duomenys išjungti"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Pasiekiama"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Pridėti SIM"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktyvi / SIM kortelė"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Neaktyvi / SIM kortelė"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Aktyvi / „eSIM“ kortelė"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Neaktyvi / „eSIM“ kortelė"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"SIM kortelės pavadinimas ir spalva"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Pavadinimas"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Spalva (naudoja suderinamos programos)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Išsaugoti"</string>
    <string name="mobile_network_use_sim_on" msgid="5333182776279917886">"Naudoti šią SIM kortelę"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Išjungta"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="7182341033728911879">"Jei norite išjungti šią SIM kortelę, išimkite SIM kortelę"</string>
    <string name="mobile_network_tap_to_activate" msgid="5280456487243915465">"Palieskite, kad suaktyvintumėte „<xliff:g id="CARRIER">%1$s</xliff:g>“ SIM kortelę"</string>
    <string name="mobile_network_erase_sim" msgid="5387971155494245850">"Ištrinti „eSIM“"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Pageidaujamas tinklo tipas"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Pakeisti tinklo veikimo režimą"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Pageidaujamas tinklo tipas"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Operatoriaus nustatymų versija"</string>
    <string name="call_category" msgid="641461844504128789">"Skambinama"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Operatoriaus vaizdo skambučiai"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Sistemos pasirinkimas"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Pakeisti tarptinklinio CDMA ryšio režimą"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Sistemos pasirinkimas"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Tinklas"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA prenumerata"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Keisti RUIM / SIM ir NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"prenumerata"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automatinė registracija…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Leisti tarptinklinį duomenų ryšį?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Daugiau kainodaros informacijos galite gauti susisiekę su tinklo paslaugų teikėju."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Programos duomenų naudojimas"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Netinkamas tinklo režimas (<xliff:g id="NETWORKMODEID">%1$d</xliff:g>). Nepaisyti."</string>
    <string name="satellite_setting_title" msgid="2543034229989047673">"Palydoviniai pranešimai"</string>
    <string name="satellite_setting_enabled_summary" msgid="3554127722727530845">"Siųskite ir gaukite teksto pranešimus per palydovą. Įtraukiama į jūsų paskyrą."</string>
    <string name="satellite_setting_disabled_summary" msgid="6789122487534159857">"Siųskite ir gaukite teksto pranešimus per palydovą. Neįtraukiama į jūsų paskyrą."</string>
    <string name="keywords_satellite_setting" msgid="3312183289776517695">"Palydoviniai pranešimai"</string>
    <string name="category_name_about_satellite_messaging" msgid="3756205049485508340">"Apie palydovinius pranešimus"</string>
    <string name="title_about_satellite_setting" msgid="9212860038048311345">"Galite siųsti ir gauti teksto pranešimus palydovo ryšiu, jei turite tinkamą „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“ paskyrą"</string>
    <string name="category_title_your_satellite_plan" msgid="3017895097366691841">"Jūsų „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“ planas"</string>
    <string name="title_have_satellite_plan" msgid="2048372355699977947">"Palydoviniai pranešimai įtraukti į jūsų paskyrą"</string>
    <string name="title_no_satellite_plan" msgid="2876056203035197505">"Palydoviniai pranešimai neįtraukti į jūsų paskyrą"</string>
    <string name="summary_add_satellite_setting" msgid="3815254731634052432">"Pridėti palydovinius pranešimus"</string>
    <string name="category_name_how_it_works" msgid="585303230539269496">"Kaip tai veikia"</string>
    <string name="title_satellite_connection_guide" msgid="3294802307913609072">"Kai neturite mobiliojo ryšio tinklo"</string>
    <string name="summary_satellite_connection_guide" msgid="3496123195218418456">"Telefonas bus automatiškai prijungtas prie palydovo. Kad užtikrintumėte geriausią ryšį, turi būti aiškiai matomas dangus."</string>
    <string name="title_supported_service" msgid="4275535165812691571">"Kai telefonas prisijungia prie palydovo"</string>
    <string name="summary_supported_service" msgid="4320535903444834786">"Galite siųsti teksto pranešimą bet kam, įskaitant pagalbos tarnybas. Telefonas bus iš naujo prijungtas prie mobiliojo ryšio tinklo, kai jis bus pasiekiamas."</string>
    <string name="satellite_setting_summary_more_information" msgid="4008690241760925372">"Palydoviniai pranešimai gali užtrukti ilgiau ir gali būti pasiekiami tik tam tikruose regionuose. Orų sąlygos ir tam tikros struktūros gali turėti įtakos palydovo ryšiui. Skambinti palydovo ryšiu negalima.\n\nGali šiek tiek užtrukti, kol paskyros pakeitimai bus parodyti „Nustatymų“ skiltyje. Kreipkitės į „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“ išsamios informacijos."</string>
    <string name="more_about_satellite_messaging" msgid="3385673133561348509">"Daugiau apie palydovinius pranešimus"</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Prieigos taškų pavadinimai"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"Prieigos taško pavadinimas"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Nepasiekiama, kai prisijungta prie „<xliff:g id="CARRIER">%1$s</xliff:g>“"</string>
    <string name="see_more" msgid="7499355691042812723">"Žr. daugiau"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Įjungti „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Įjungti SIM kortelę?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Perjungti į „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Perjungti į SIM kortelę?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Naudoti „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="7474905814976249607">"Vienu metu gali būti tik viena SIM kortelė.\n\nPerjungus į „<xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>“ jums teikiamos „<xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>“ paslaugos nebus atšauktos."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="6415848271400253954">"Vienu metu gali būti tik viena „eSIM“ kortelė.\n\nPerjungus į „<xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>“ jums teikiamos „<xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>“ paslaugos nebus atšauktos."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="421658355882679837">"Vienu metu gali būti tik viena SIM kortelė.\n\nPerjungus jums teikiamos „<xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>“ paslaugos nebus atšauktos."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Vienu metu galite naudoti dvi SIM korteles. Jei norite naudoti „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“, išjunkite vieną iš SIM kortelių."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Perjungti į „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“"</string>
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off" msgid="5392037608705799522">"Išjungti „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Išjungus SIM kortelę, paslauga nebus atšaukta"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="8144175623622669136">"Aktyvinama SIM kortelė…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="697127154780501304">"Perjungiama į „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="2718084141744769701">"Nepavyko perjungti SIM kortelės"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="8332742656111984482">"Kažkas nepavyko. Nepavyko perjungti SIM kortelės."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Išjungti „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Išjungti SIM kortelę?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Išjungiama SIM kortelė<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="1808735136395980905">"Nepavyko išjungti SIM kortelės"</string>
    <string name="privileged_action_disable_fail_text" msgid="6236231745255527458">"Kažkas nepavyko ir jūsų SIM kortelė nebuvo išjungta."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Naudoti dvi SIM korteles?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Šiame įrenginyje vienu metu gali būti dvi aktyvios SIM kortelės. Jei norite toliau naudoti vieną SIM kortelę vienu metu, palieskite „Ne, ačiū“."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Paleisti įrenginį iš naujo?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Taip"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Paleisti iš naujo"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Ne, ačiū"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Atšaukti"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Perjungti"</string>
    <string name="sim_action_turn_off" msgid="3506698692916473000">"Išjungti"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Nepavyko suaktyvinti SIM kortelės"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Pabandykite vėl įjungti SIM kortelę. Jei problema išlieka, iš naujo paleiskite įrenginį."</string>
    <string name="sim_onboarding_bottomsheets_title" msgid="143711121394213711">"SIM kortelės nustatymas"</string>
    <string name="sim_onboarding_bottomsheets_msg" msgid="7367245016476460849">"Nustatykite mobiliojo ryšio tinklo nuostatas, kad galėtumėte naudoti kelias SIM korteles šiame įrenginyje"</string>
    <string name="sim_onboarding_label_sim_title" msgid="273162565849288273">"SIM kortelių etikečių pridėjimas"</string>
    <string name="sim_onboarding_label_sim_msg" msgid="5105859235219529056">"Šios etiketės bus rodomos skambinant, siunčiant teksto pranešimus ir naudojant duomenis bei „Nustatymų“ skiltyje"</string>
    <string name="sim_onboarding_label_sim_dialog_title" msgid="5839073125605286120">"SIM kortelės etiketė"</string>
    <string name="sim_onboarding_label_sim_dialog_label" msgid="9020433985426525185">"Etiketė"</string>
    <string name="sim_onboarding_select_sim_title" msgid="5895262188167744055">"Naudotinų SIM kortelių pasirinkimas"</string>
    <string name="sim_onboarding_select_sim_msg" msgid="5638859405391915048">"Vienu metu galite naudoti dvi SIM korteles"</string>
    <string name="sim_onboarding_primary_sim_title" msgid="2793090401371135675">"Pagrindinių SIM kortelių nustatymas"</string>
    <string name="sim_onboarding_primary_sim_msg" msgid="5484656671490558032">"Pasirinkite, kurias SIM korteles naudoti pagal numatytuosius nustatymus skambučiams, teksto pranešimams ir duomenims"</string>
    <string name="primary_sim_title" msgid="2508161011657571566">"Pagrindinės SIM kortelės"</string>
    <string name="primary_sim_calls_title" msgid="4961189133582615685">"Skambučiai"</string>
    <string name="primary_sim_texts_title" msgid="1287584042733097749">"Teksto pranešimai"</string>
    <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatinis duomenų perjungimas"</string>
    <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Naudoti duomenis iš bet kurios SIM kortelės, atsižvelgiant į aprėptį ir pasiekiamumą"</string>
    <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Tik duomenys"</string>
    <string name="sim_onboarding_setup" msgid="5750393553605388463">"Nustatyti"</string>
    <string name="sim_onboarding_next" msgid="6415025179929475355">"Kitas"</string>
    <string name="sim_onboarding_progressbar_turning_sim_on" msgid="1163318788393361574">"Įjungiama „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“…"</string>
    <string name="mobile_network_spn_title" msgid="3053793174495329077">"Mobiliojo ryšio tinklas"</string>
    <string name="mobile_network_phone_number_title" msgid="2090794402855021784">"Telefono numeris"</string>
    <string name="mobile_network_sim_label_color_title" msgid="2401352348041132876">"SIM etiketė ir spalva"</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Tinklo aktyvinimas"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Operatoriaus keitimas"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="975447139749692794">"„<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“ SIM kortelė yra aktyvi"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Palieskite ir atnaujinkite SIM nustatymus"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Perjungta į „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Perjungta į kitą operatorių"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Mobiliojo ryšio tinklas pakeistas"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Nustatykite kitą SIM kortelę"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Pasirinkite aktyvią SIM kortelę arba naudokite 2 SIM korteles vienu metu"</string>
    <string name="choose_sim_title" msgid="66509047151583877">"Pasirinkite norimą naudoti SIM kortelę"</string>
    <string name="choose_sim_text" msgid="8992163497852069924">"{count,plural, =1{1 SIM kortelė pasiekiama šiame įrenginyje, bet vienu metu galima naudoti tik vieną}=2{2 SIM kortelės pasiekiamos šiame įrenginyje, bet vienu metu galima naudoti tik vieną}one{# SIM kortelė pasiekiama šiame įrenginyje, bet vienu metu galima naudoti tik vieną}few{# SIM kortelės pasiekiamos šiame įrenginyje, bet vienu metu galima naudoti tik vieną}many{# SIM kortelės pasiekiama šiame įrenginyje, bet vienu metu galima naudoti tik vieną}other{# SIM kortelių pasiekiama šiame įrenginyje, bet vienu metu galima naudoti tik vieną}}"</string>
    <string name="choose_sim_activating" msgid="6485547671356386998">"Įjungiama<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="866488735834045525">"Šiuo metu nepavyko įjungti šios SIM kortelės"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Naudoti „<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"„<xliff:g id="CARRIER_NAME">%1$s</xliff:g>“ ryšys bus naudojamas mobiliojo ryšio duomenims, skambučiams ir SMS žinutėms."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Nėra jokių pasiekiamų aktyvių SIM kortelių"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Kad vėliau galėtumėte naudoti mobiliojo ryšio duomenis, skambučių ir SMS funkcijas, eikite į tinklo nustatymus"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM kortelė"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Ištrinti šią „eSIM“ kortelę?"</string>
    <string name="erase_sim_dialog_text" msgid="1406141218170595272">"Tai atlikus „<xliff:g id="CARRIER_NAME_A">%1$s</xliff:g>“ paslauga bus pašalinta iš šio įrenginio, bet jūsų turimas „<xliff:g id="CARRIER_NAME_B">%1$s</xliff:g>“ planas nebus atšauktas."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Ištrinti"</string>
    <string name="erasing_sim" msgid="4237180547590463930">"Trinama „eSIM“ kortelė…"</string>
    <string name="erase_sim_fail_title" msgid="1445700500168357303">"Nepavyko ištrinti „eSIM“ kortelės"</string>
    <string name="erase_sim_fail_text" msgid="6898841004987411547">"Kažkas nepavyko ir ši „eSIM“ kortelė nebuvo ištrinta.\n\nIš naujo paleiskite įrenginį ir bandykite dar kartą."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Prijungimas prie įrenginio"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Programa „<xliff:g id="APPNAME">%1$s</xliff:g>“ nori naudoti laikiną „Wi‑Fi“ tinklą, kad galėtų prisijungti prie jūsų įrenginio"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Nerasta jokių įrenginių. Įsitikinkite, kad įrenginiai įjungti ir prie jų galima prisijungti."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Bandyti dar kartą"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Kažkas nutiko. Programa atšaukė įrenginio pasirinkimo užklausą."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Sėkmingai prisijungta"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Nepavyko užmegzti ryšio"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Rodyti viską"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Ieškoma įrenginio…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Prisijungiama prie įrenginio…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Kairėje"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Dešinėje"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Dėklas"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Nustatymų skydelis"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Priverstinai įjungti darbalaukio režimą"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Priverstinai įjungti eksperimentinį darbalaukio režimą antriniuose ekranuose"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Įgalinti nekeičiamo dydžio progr. naud. kelių langų funkciją"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Leidžiama naudoti nekeičiamo dydžio programas su kelių langų funkcija"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Nepaisyti priverst. tamsaus rež. įgalin."</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Nepaisoma priverstinio tamsaus režimo funkcijos įgalinimo, kad ji visada būtų įjungta"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privatumas"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Leidimai, paskyros veikla, asmens duomenys"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Valdikliai"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Pašalinti"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Keep"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Pašalinti šį siūlymą?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Liko mažai saugyklos vietos. Naudojama: <xliff:g id="PERCENTAGE">%1$s</xliff:g>, laisva: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Siųsti atsiliepimą"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Ar norite pateikti atsiliepimų dėl šio pasiūlymo?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"Turinys (<xliff:g id="COPY_CONTENT">%1$s</xliff:g>) nukopijuotas į iškarpinę."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Pritaikymo neįgaliesiems naudojimas"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{Vienai programai suteikta visateisė prieiga prie jūsų įrenginio}one{# programai suteikta visateisė prieiga prie jūsų įrenginio}few{# programoms suteikta visateisė prieiga prie jūsų įrenginio}many{# programos suteikta visateisė prieiga prie jūsų įrenginio}other{# programų suteikta visateisė prieiga prie jūsų įrenginio}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Svarbi informacija"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"TĘSTI"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"AČIŪ, NE"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Vietovė"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Operatorius gali rinkti vietovės duomenis, kai naudojatės šia paslauga norėdami atlikti skambučius pagalbos numeriu.\n\nApsilankykite operatoriaus privatumo politikos puslapyje, jei reikia išsamios informacijos."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Galite prarasti galimybę pasiekti likusį laiką ar duomenis. Prieš pašalindami pasikonsultuokite su teikėju."</string>
    <string name="content_capture" msgid="868372905432812238">"Programos turinys"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Leisti programai siųsti turinį į „Android“ sistemą"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Fiksuoti sistemos atminties išklotinę"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Atminties žymėjimo plėtinys"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Naudojant atminties žymėjimo plėtinį (angl. „Memory Tagging Extensions“, MTE) lengviau rasti atminties saugos problemas programoje ir padaryti savąjį kodą saugesnį."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Įjungus MTE gali sulėtėti įrenginio veikimas."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Sužinokite daugiau apie MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Įgalinti MTE, kol išjungsite"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Norėdami įjungti MTE, turėsite paleisti įrenginį iš naujo."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Norėdami išjungti MTE, turėsite paleisti įrenginį iš naujo."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"MTE įgalinimas vienam seansui"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Sistema bus paleista iš naujo ir leidžiama eksperimentuoti su atminties žymėjimo plėtiniu (angl. „Memory Tagging Extensions“, MTE). MTE gali neigiamai paveikti sistemos našumą ir stabilumą. Bus iš naujo nustatyta kitą kartą paleidus iš naujo."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Paleisti iš naujo vienam seansui įgalinus MTE"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"MTE jau įgalintas"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Sistemos atminties išklotinės fiksavimas"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Nepavyko užfiksuoti sistemos atminties išklotinės"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Automatinis sistemos atminties išklotinių fiksavimas"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Automatiškai fiksuoti „Android“ sistemos atminties išklotinę, kai naudojama per daug atminties"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Atsijungti"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Skambučiai pagalbos numeriu"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Jūsų operatorius nepalaiko skambučių pagalbos numeriu naudojant „Wi‑Fi“ skambinimo funkciją.\nSkambinant pagalbos numeriu automatiškai perjungiama į įrenginio mobiliojo ryšio tinklą.\nSkambinti pagalbos numeriu galima, tik kur veikia mobilusis ryšys."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Naudokite „Wi‑Fi“ skambučiams atlikti, kad pagerintumėte kokybę"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Gaunamas MMS pranešimas"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Nepavyko išsiųsti MMS pranešimo"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Palieskite, kad leistumėte siųsti MMS pranešimus „<xliff:g id="OPERATOR_NAME">%1$s</xliff:g>“ tinkle, kai mobiliojo ryšio duomenys išjungti"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS pranešimas"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problema dėl SIM kortelių derinio"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Naud. operatorių <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> paslaug. gali būti apribotas funkcionalumas. Palieskite, kad sužinotumėte daugiau."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"SIM kortelių derinys"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Darbo politikos informacija"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Nustatymus tvarko jūsų IT administratorius"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"Grafikos procesorius"</string>
    <string name="enable_16k_pages" msgid="5009476566957520607">"Paleisti su 16 K puslapio dydžiu"</string>
    <string name="enable_16k_pages_summary" msgid="428117226069445198">"Paleisti įrenginį su 16 K psl. palaik. branduoliu"</string>
    <string name="confirm_enable_16k_pages_title" msgid="6751570067857011642">"Paleisti iš naujo naudojant su 16 KB puslapiais suderinamą branduolį?"</string>
    <string name="confirm_enable_16k_pages_text" msgid="702888115148257215">"PERSPĖJIMAS: kai kurios programos gali būti nesuderinamos su šiuo režimu. Patvirtinus įrenginys bus paleistas iš naujo."</string>
    <string name="confirm_enable_4k_pages_title" msgid="626987400420355263">"Paleisti iš naujo naudojant su 4 KB puslapiais suderinamą branduolį?"</string>
    <string name="confirm_enable_4k_pages_text" msgid="6168921566226074524">"Patvirtinus įrenginys bus paleistas iš naujo."</string>
    <string name="toast_16k_update_failed_text" msgid="8888858987184345567">"Nepavyko atnaujinti į su 16 KB puslapiais suderinamą branduolį"</string>
    <string name="progress_16k_ota_title" msgid="2117218313875523741">"Pritaikomas pakeitimas"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Pranešimų apie riktus doroklė"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Nustatoma, kuri programa apdoroja pranešimo apie riktą spartųjį klavišą įrenginyje."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Asmeninė"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Darbo"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Numatytasis sistemos nustatymas"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Nėra"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Šios parinkties nebegalima pasirinkti. Bandykite dar kartą."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Paspauskite ir palaikykite maitinimo mygtuką"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Paspauskite ir palaikykite maitinimo mygtuką prieigai"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Įjungimo meniu"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Skaitmeninis pagelbiklis"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Pasiekite skaitmeninį pagelbiklį"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Pasiekite įjungimo meniu"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Jei norite naudoti, pirmiausia nustatykite ekrano užraktą"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Įjungimo meniu:\npaspauskite maitinimo ir garsumo mygtukus tuo pačiu metu"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Skambėjimo išjungimas:\nnorėdami naudoti spartųjį klavišą paspauskite garsumo mygtuką"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Laikymo paspaudus trukmė"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Koreguokite jautrumą nustatydami, kaip ilgai reikia laikyti paspaudus maitinimo mygtuką"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Trumpai"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Ilgai"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Rodyti piniginę"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Leisti pasiekti piniginę iš užrakinimo ekrano"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Rodyti QR kodų skaitytuvą"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Leisti prieigą prie QR kodų skaitytuvo iš užrakinimo ekrano"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Rodyti įrenginio valdiklius"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Iš užrakinimo ekrano"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Įrenginio valdiklių naudojimas"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Jei norite naudoti, pirmiausia įjunkite parinktį „Rodyti įrenginio valdiklius“"</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"Laikrodžio dydis keičiamas pagal užrakinimo ekrano turinį"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Dinaminis laikrodis"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Spartieji klavišai"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="one"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="few"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="many"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
    </plurals>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Išjungti „VoLTE“?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Taip pat bus išjungtas 5G ryšys.\nVykstant balso skambučiui negalima naudoti interneto ir kai kurios programos gali neveikti."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Sustabdykite talpykloje išsaugotų programų vykdymą"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Galioja visada."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Nuoma niekada nenutrūksta."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Leisti ekranų perdangas skiltyje „Nustatymai“"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Leiskite virš kitų programų rodomoms programoms perdengti skilties „Nustatymai“ ekranus"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Leisti imituojamą modemą"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Leisti šiame įrenginyje vykdyti imituojamo modemo paslaugą atliekant stebimumo ir vertinamumo bandymą. Neįgalinkite įprastai naudodami telefoną"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications" msgid="4987116103699222633">"Ekrano bendrinimo apsaugos išjungimas"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications_summary" msgid="932295234626582052">"Išjungiama sistemos taikoma programa ir pranešimų apsauga bendrinant ekraną"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Medija"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Medijos leistuvės prisegimas"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Kad būtų galima sparčiai atnaujinti atkūrimą, medijos leistuvė lieka atidaryta „Sparčiųjų nustatymų“ skiltyje"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Rodyti mediją užrakinimo ekrane"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Kad būtų galima sparčiai atnaujinti atkūrimą, medijos leistuvė lieka atidaryta užrakinimo ekrane"</string>
    <string name="media_controls_recommendations_title" msgid="3012692549413927608">"Rodyti Padėjėjo medijos rekomendacijas"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Pagrįsta jūsų veikla"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Slėpti leistuvę"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Rodyti leistuvę"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"medija"</string>
    <string name="camera_extensions_fallback_title" msgid="3604579046777004989">"Fotoaparato programinės įrangos plėtinių leidimas"</string>
    <string name="camera_extensions_fallback_description" msgid="6939818294458854536">"Įgalinamas numatytasis išplėstinių fotoaparato funkcijų, pvz., „Eyes Free“ videografijos, programinės įrangos diegimas."</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bus įjungtas „Bluetooth“"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internetas"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Skambučiai ir SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"„Wi-Fi“ skambinimas"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Atlikite ir gaukite skambučius naudodami „Wi‑Fi“"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Skambučiai"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"pageidaujama"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"pageidautina skambučiams"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"pageidautina SMS žinutėms"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"nepasiekiama"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Laikinai nepasiekiama"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Nėra SIM kortelės"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Tinklo nuostatos"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"tinklo ryšys, internetas, belaidis ryšys, duomenys, „Wifi“, „Wi-Fi“, „Wi Fi“, mobilusis ryšys, mobilusis, mobiliojo ryšio operatorius, 4G, 3G, 2G, LTE"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Nustatyti internetą iš naujo?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Internetas nustatomas iš naujo…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Tvarkyti ryšį"</string>
    <string name="networks_available" msgid="3299512933684383474">"Pasiekiami tinklai"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Norėdami perjungti tinklus, atjunkite eternetą"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"W+ ryšiai"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Leiskite „Google Fi“ naudoti W+ tinklus, kad būtų padidinta sparta ir aprėptis"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"W+ tinklas"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM kortelė"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"„eSIM“ kortelė"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"„eSIM“ kortelės"</string>
    <string name="sim_category_active_sim" msgid="3077009911935592178">"Įjungta"</string>
    <string name="sim_category_inactive_sim" msgid="7351553344148400450">"Išjungta"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Numatytoji <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"skambučiams"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"mobiliojo ryšio duomenims"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Kad pagerintų įrenginio funkcijas, programos ir paslaugos vis tiek gali bet kada nuskaityti ieškodamos „Wi‑Fi“ tinklų, net jei „Wi‑Fi“ išjungtas. Tai gali būti naudojama siekiant pagerinti pagal vietovę teikiamas funkcijas ir paslaugas. Tai galite pakeisti „Wi-Fi“ nuskaitymo nustatymuose."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Pakeisti"</string>
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g> / <xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Prisijungta"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Laikinai prijungta"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Laikinai naudojama „<xliff:g id="SUBNAME">%1$s</xliff:g>“"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Nėra ryšio"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Naud. mob. r. duomenis nebus autom. prisijungiama"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Išjungti mobiliojo ryšio duomenis?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Naudodamiesi „<xliff:g id="CARRIER">%s</xliff:g>“ paslaugomis neturėsite galimybės pasiekti duomenų arba interneto. Internetą galėsite naudoti tik prisijungę prie „Wi-Fi“."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"jūsų operatorius"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Jūsų organizacijoje neleidžiama"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Nepasiekiama, nes įjungtas laiko eiti miegoti režimas"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Pranešimų svarba nustatyta iš naujo."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Programos"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Įrenginys nori pasiekti jūsų pranešimus. Palieskite, jei reikia išsamios informacijos."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Leisti pasiekti pranešimus?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"„Bluetooth“ įrenginys „<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>“ nori pasiekti jūsų pranešimus.\n\nPrie „<xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>“ dar niekada nebuvote prisijungę."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Įrenginys nori pasiekti jūsų kontaktus ir skambučių žurnalą. Palieskite, jei reikia išsamios informacijos."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Leisti pasiekti kontaktus ir skambučių žurnalą?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"„Bluetooth“ įrenginys „<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>“ nori pasiekti jūsų kontaktus ir skambučių žurnalą. Tai apima duomenis apie gaunamuosius ir siunčiamuosius skambučius.\n\nPrie „<xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>“ dar niekada nebuvote prisijungę."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Šviesumas"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Užrakinimo ekranas"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Išvaizda"</string>
    <string name="category_name_color" msgid="937514550918977151">"Spalva"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Kiti ekrano valdikliai"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Bendrieji"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Tamsiosios temos naudojimas"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"„Bluetooth“ naudojimas"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Skambėjimo stabdymo funkcijos naudojimas"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"„Wi‑Fi“ viešosios interneto prieigos taško naudojimas"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Programos prisegimo naudojimas"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Kūrėjo parinkčių naudojimas"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Naudoti spausdinimo paslaugą"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Kelių naudotojų leidimas"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"leisti, keli, naudotojas, leidimas, daug"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Belaidžio ryšio derinimo naudojimas"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Grafikos tvarkyklės nuostatų naudojimas"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Nakties šviesos naudojimas"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"NFC naudojimas"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Prisitaikančio šviesumo naudojimas"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"„Wi‑Fi“ skambinimo naudojimas"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Žr. visas programas"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Išmanusis peradresavimas"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Išmanusis peradresavimas įgalintas"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Išmanusis peradresavimas išjungtas"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Skambučių nustatymai"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Atnaujinami nustatymai..."</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Skambinimo nustatymų klaida"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Tinklo arba SIM kortelės klaida."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM kortelė nesuaktyvinta."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Įveskite telefono numerius"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Įveskite telefono numerį"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Nėra telefono numerio."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"Gerai"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Leisti 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G ne toks saugus, bet kai kur ryšys gali būti geresnis. 2G visada leidžiama naudoti skambučiams pagalbos numeriu."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"„<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g>“ būtinas 2G"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Reikalauti šifruotės"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Šifruotės metodas saugesnis, bet gali nepavykti prisijungti kai kuriose vietovėse. Skambučiams pagalbos numeriu šifruotė niekada nereikalinga"</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Visos paslaugos"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Rodyti iškarpinės prieigą"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Rodyti pranešimą, kai programos pasiekia nukopijuotą tekstą, vaizdus ar kitą turinį"</string>
    <string name="all_apps" msgid="3054120149509114789">"Visos programos"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Neleisti"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultraplačiajuostė ryšio technologija (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Padeda nustatyti santykinį atstumą nuo netoliese esančių įrenginių su UWB"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Norėdami naudoti UWB, išjunkite lėktuvo režimą"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB ryšys nepasiekiamas dabartinėje vietovėje"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Prieiga prie fotoaparato"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Prieiga prie mikrofono"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Programos ir paslaugos"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Programos ir paslaugos. Jei šis nustatymas išjungtas, mikrofono duomenys vis tiek gali būti bendrinami, skambinant pagalbos numeriu."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Ankstesnis"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Kitas"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Spalvos peržiūra"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"SIM kortelės prieigos užklausa"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Įrenginys nori pasiekti jūsų SIM kortelę. Palieskite, jei reikia išsamios informacijos."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Leisti pasiekti SIM kortelę?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"„Bluetooth“ įrenginys „<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>“ nori pasiekti duomenis iš jūsų SIM kortelės. Tai apima jūsų kontaktus.\n\nPrisijungęs įrenginys „<xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>“ gaus visus telefono numeriu <xliff:g id="PHONE_NUMBER">%3$s</xliff:g> atliktus skambučius."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Pasiekiamas „Bluetooth“ įrenginys"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Įrenginys nori prisijungti. Palieskite, jei reikia išsamios informacijos."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Prisijungti prie „Bluetooth“ įrenginio?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> nori prisijungti prie šio telefono.\n\nAnksčiau nebuvote prisijungę prie <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Neprisijungti"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Susieti"</string>
    <string name="tare_settings" msgid="3788654800004869077">"TARE nustatymai"</string>
    <string name="tare_on" msgid="2386073225978684535">"Įjungta"</string>
    <string name="tare_off" msgid="6305694402929756726">"Išjungta"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Grąžinti numatytuosius nustatymus"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Nustatymai grąžinti į numatytuosius."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Didžiausias visiško įkrovimo balansas"</string>
    <string name="tare_balances" msgid="731881382594747961">"Balansas"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Vartojimo apribojimai"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Padinis vartojimo apribojimas"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Mažiausias vartojimo apribojimas"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Didžiausias vartojimo apribojimas"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modifikatoriai"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Veiksmai (gamybos mokestis)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Veiksmai (bazinė kaina)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Premijos per vieną įvykį"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Premijos už įvykio trukmę sekundėmis"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Didžiausias premijų skaičius per dieną"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Programos diegimas"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Populiariausia veikla"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Pranešimas peržiūrėtas"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Pranešimas peržiūrėtas per 15 minučių"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Sąveika su pranešimu"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Sąveika su valdikliu"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Kita naudotojo sąveika"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Didž. prioriteto užduoties pradėjimas"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Vykdoma didžiausio prioriteto užduotis"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Didelio prioriteto užduoties pradėjimas"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Vykdoma didelio prioriteto užduotis"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Numatytosios užduoties pradėjimas"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Vykdoma numatytoji užduotis"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Mažo prioriteto užduoties pradėjimas"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Vykdoma mažo prioriteto užduotis"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Mažiaus. prioriteto užduoties pradėjimas"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Vykdoma mažiausio prioriteto užduotis"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Užduoties skirtojo laiko bauda"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Mažiausias visiško įkrovimo balansas (pritaikyta išimtis)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Mažiausias visiško įkrovimo balansas (sist. programa be grafinės naud. sąsajos)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Mažiausias visiško įkrovimo balansas (likusios programos)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Mažiausio visiško įkrovimo balans pridėjimas (programų atnaujinimo priemonės)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Įkrovimas"</item>
    <item msgid="658627268149681677">"Snustelėjimas"</item>
    <item msgid="1599558140284643834">"Energijos tausojimo režimas"</item>
    <item msgid="588427840913221601">"Apdorojimo būsena"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Patvirtinti"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Peržiūrėti"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Ekrano užsklandos pasirinkimas"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Papildomos informacijos rodymas"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Rodyti tokią informaciją kaip laikas, orai ir pan. ekrano užsklandoje"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Namų sistemos valdiklių rodymas"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Rodyti namų sistemos valdymo mygtuką ekrano užsklandoje"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Daugiau nustatymų"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Ekrano užsklandos pasirinkimas"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Pasirinkite, kas bus rodoma ekrane, kai planšetinis kompiuteris bus prijungtas prie doko. Naudojant ekrano užsklandą gali būti eikvojama daugiau įrenginio energijos."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Tinkinti"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Tinkinti skiltį „<xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>“"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Norint įgalinti laisvos formos palaikymą, būtina paleisti iš naujo."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Norint priverstinai įjungti darbalaukio režimą antriniuose ekranuose, būtina paleisti iš naujo."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Paleisti iš naujo dabar"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Paleisti iš naujo vėliau"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Erdvinis garsas"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Kokybiškesnis suderinamos medijos garsas"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Galvos stebėjimas"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Garso pakeitimai, kad garsas skambėtų natūraliau judinant galvą"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="7277580382321003521">"Leidimų iš telefono sinchronizavimas"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="8125037984381432059">"Suteikite laikrodžiui tuos pačius programų leidimus, kuriuos suteikėte šiame telefone"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Garso įrenginio tipas"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Nežinoma"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Garsiakalbis"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Ausinės"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Klausos aparatas"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Automobilinė įranga"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Kita"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Tinklo atsisiuntimo rodiklio apribojimas"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Konfigūruokite tinklo pralaidumo įvesties rodiklio apribojimą, kuris taikomas visiems tinklams, teikiantiems interneto ryšį."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Konfigūruokite tinklo atsisiuntimo rodiklio apribojimą"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Nėra apribojimų"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Antrinių procesų apribojimų išjungimas"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Išjungti programos antrinių procesų sistemos išteklių naudojimo apribojimus"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Priverstinis pastabų vaidmens įgalinimas"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Įgalinkite pastabų rašymo sistemos integravimą priskirdami pastabų vaidmenį. Jei pastabų vaidmuo jau įgalintas, nereikia atlikti jokių veiksmų. Reikia paleisti iš naujo."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Transliacija"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Transliuoti „<xliff:g id="CURRENTAPP">%1$s</xliff:g>“"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Klausykite netoliese leidžiamų transliacijų"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Transliuokite mediją įrenginiuose netoliese arba klausykite kitų transliacijų"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Transliacijos"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Klausoma"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Rasti transliacijų"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Išeiti iš transliacijos"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Nuskaityti QR kodą"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Įveskite slaptažodį"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Nepavyko prisijungti. Bandykite dar kartą."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Netinkamas slaptažodis"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Nepavyko prisijungti prie transliacijos"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Jei norite pradėti klausyti, nustatykite toliau pateiktą QR kodą per vidurį"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"QR kodas netinkamo formato"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Konvertavimas į „eSIM“ kortelę"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Perkelti „eSIM“ kortelę į kitą įrenginį"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# programa}one{# programa}few{# programos}many{# programos}other{# programų}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Fone įdiegtos programos"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Jūsų įrenginio gamintojas gali įdiegti programų jūsų įrenginyje, fone, arba leisti tai padaryti operatoriui ir kitiems partneriams.\n\nVisos čia nurodytos programos nėra būtinos, kad įrenginys veiktų įprastai. Galite pašalinti nenorimas programas."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Nėra fone įdiegtų programų"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Pašalinti programą"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Programos įdiegtos per pastarąjį # mėnesį}one{Programos įdiegtos per pastaruosius # mėnesį}few{Programos įdiegtos per pastaruosius # mėnesius}many{Programos įdiegtos per pastaruosius # mėnesio}other{Programos įdiegtos per pastaruosius # mėnesių}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Programos įdiegtos daugiau nei prieš # mėnesį}one{Programos įdiegtos daugiau nei prieš # mėnesį}few{Programos įdiegtos daugiau nei prieš # mėnesius}many{Programos įdiegtos daugiau nei prieš # mėnesio}other{Programos įdiegtos daugiau nei prieš # mėnesių}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Kraštinių santykis"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Išbandykite naują kraštinių santykių ir peržiūrėkite, kaip atrodytų ši programa, jei nebūtų sukurta jūsų „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“"</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Išbandykite naują kraštinių santykių ir peržiūrėkite, kaip atrodytų ši programa, jei nebūtų sukurta jūsų „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“ Kai kurios programos gali būti neoptimizuotos pagal tam tikrus kraštinių santykius."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Išbandykite naują kraštinių santykį ir peržiūrėkite, kaip atrodytų programa, jei nebūtų sukurta jūsų „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Išbandykite naują kraštinių santykį ir peržiūrėkite, kaip atrodytų programa, jei nebūtų sukurta jūsų „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“. Kai kurios programos gali būti neoptimizuotos pagal tam tikrus kraštinių santykius."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Siūlomos programos"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Pakeistos pr."</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Numatytasis programos nustatymas"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Viso ekrano režimas"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Pusė ekrano"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Įrenginio kraštinių santykis"</string>
    <string name="user_aspect_ratio_16_9" msgid="2286644872775170164">"16:9"</string>
    <string name="user_aspect_ratio_3_2" msgid="199262962518318932">"3:2"</string>
    <string name="user_aspect_ratio_4_3" msgid="5196232982878982220">"4:3"</string>
    <string name="user_aspect_ratio_option_a11y" msgid="1235801996029095219">"<xliff:g id="NUMERATOR">%1$s</xliff:g> ir <xliff:g id="DENOMINATOR">%2$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"Programa bus paleista iš naujo, kai pakeisite kraštinių santykį. Neišsaugoti pakeitimai gali būti prarasti. Kai kurios programos gali būti neoptimizuotos pagal tam tikrus kraštinių santykius."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Kraštinių santykis (eksperimentinis)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Kraštinių santykis (eksperimentas)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Kraštinių santykis (laboratorijos)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Eksperimentinė versija"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Eksperimentas"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Laboratorijos"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Piršto atspaudo jutiklis"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Mirksėjimo pranešimai"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Apie mirksėjimo pranešimus"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Išjungta"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Įjungta / fotoaparato blykstė"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Įjungta / ekrano mirksėjimas"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Įjungta / fotoaparato blykstė ir ekrano mirksėjimas"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Įjungti fotoaparato blykstę arba ekraną gavus pranešimų ar nuskambėjus signalui"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Įjungti ekrano apšvietimą gavus pranešimų ar nuskambėjus signalui"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Naudokite mirksėjimo pranešimus apdairiai, jei esate jautrūs šviesai"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"blykstė, apšvietimas, neprigirdintis asmuo, klausos sutrikimai"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Peržiūrėti"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Fotoaparato blykstė"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Ekrano mirksėjimas"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Ekrano mirksėjimo spalva"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Mėlyna"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Žydra"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Žalsvai mėlyna"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Šviesiai žalia"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Žalia"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Skaisčiai žalia"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Geltona"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Oranžinė"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Raudona"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Rožinė"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Purpurinė"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Violetinė"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Atlikta"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Atšaukti"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Kontrastas"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Įprastas"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Vidutinis"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Aukštas"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Šią programą galima atidaryti tik viename lange"</string>
    <string name="generic_accessibility_service_on" msgid="4466229372357726824">"Įjungta"</string>
    <string name="generic_accessibility_service_off" msgid="4759859497651675724">"Išjungta"</string>
    <string name="generic_accessibility_feature_shortcut_off" msgid="4022872394514077907">"Išjungta"</string>
    <string name="accessibility_shortcut_state_off" msgid="8158137799007601475">"Išjungta"</string>
    <string name="daltonizer_state_on" msgid="131013270022603983">"Įjungta"</string>
    <string name="daltonizer_state_off" msgid="1162285688069856179">"Išjungta"</string>
    <string name="color_inversion_state_on" msgid="1160969033636440368">"Įjungta"</string>
    <string name="color_inversion_state_off" msgid="6925638668080451724">"Išjungta"</string>
    <string name="color_inversion_feature_summary" msgid="1199876648549627647">"Šviesūs ekranai tampa tamsūs, o tamsūs – šviesūs"</string>
    <string name="magnification_feature_summary" msgid="2053971569640663564">"Artinti ekrane"</string>
    <string name="autoclick_disabled" msgid="3213396804955002120">"Išjungta"</string>
    <string name="show_captions_disabled" msgid="690650956523818755">"Išjungta"</string>
    <string name="show_captions_enabled" msgid="7089043007924626">"Įjungta"</string>
    <string name="live_caption_disabled" msgid="3562035026547887366">"Išjungta"</string>
    <string name="live_caption_enabled" msgid="5269360946200718949">"Įjungta"</string>
    <string name="about_phone_device_name_warning" msgid="3243226572404472381">"Įrenginio pavadinimas matomas jūsų įdiegtoms programoms. Kai prisijungiate prie „Bluetooth“ įrenginių ar „Wi-FI“ tinklo arba nustatote „Wi-Fi“ viešosios interneto prieigos tašką, jį taip pat gali matyti kiti žmonės."</string>
    <string name="grammatical_gender_title" msgid="8584242850477270828">"Gramatinė giminė"</string>
    <string name="grammatical_gender_dialog_title" msgid="8754048592099871587">"Pasirinkite gramatinę giminę"</string>
    <string name="content_protection_preference_title" msgid="5069260032659193074">"Nuskaitoma ieškant apgaulingų programų"</string>
    <string name="content_protection_preference_summary" msgid="2252393849408445391">"Patikrinkite programų aktyvumą dėl sukčiavimo"</string>
    <string name="content_protection_preference_user_consent_switch_title" msgid="1797782616799594426">"Atlikti apgaulingų programų nuskaitymą"</string>
    <string name="content_protection_preference_user_consent_work_profile_switch_title" msgid="3004347470520916069">"Atlikti apgaulingų darbo programų nuskaitymą"</string>
    <string name="content_protection_preference_subpage_summary" msgid="3595621220981703364"></string>
    <string name="content_protection_preference_subpage_info" msgid="6890886357653365489"></string>
    <string name="accessibility_setup_password_complete" msgid="6358749253318369077">"Slaptažodis dabar nustatytas"</string>
    <string name="show_stylus_pointer_icon" msgid="1010583689203665786">"Rodyti rodyklę, kol ji laikoma užvesta virš parinkties"</string>
</resources>
