<?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="application_name" msgid="1935869255545976415">"Naršyklė"</string>
    <string name="choose_upload" msgid="3649366287575002063">"Pasirinkti failą, kurį norite įkelti"</string>
    <string name="uploads_disabled" msgid="463761197575372994">"Neleidžiama įkelti failų."</string>
    <!-- outdated translation 4505722538297295141 -->     <string name="new_tab" msgid="7971857320679510529">"Naujas langas"</string>
    <string name="new_incognito_tab" msgid="3606197964239039478">"Naujas inkognito skirtukas"</string>
    <string name="tab_bookmarks" msgid="2305793036003473653">"Žymės"</string>
    <string name="tab_most_visited" msgid="1077402532455000703">"Dažniausiai lankomos"</string>
    <string name="tab_history" msgid="1979267558744613746">"Istorija"</string>
    <string name="tab_snapshots" msgid="4435852763803720588">"Išsaugoti puslapiai"</string>
    <string name="added_to_bookmarks" msgid="1020224130695956728">"Pridėta prie žymių"</string>
    <string name="removed_from_bookmarks" msgid="6063705902028438800">"Pašalinta iš žymių"</string>
    <string name="sign_in_to" msgid="5939425800148759165">"Prisijungti prie <xliff:g id="HOSTNAME">%s1</xliff:g> „<xliff:g id="REALM">%s2</xliff:g>“"</string>
    <string name="username" msgid="5057566336518215922">"Pavadinimas"</string>
    <string name="password" msgid="1177138552305184404">"Slaptažodis"</string>
    <string name="action" msgid="183105774472071343">"Prisijungti"</string>
    <string name="bookmarks_search" msgid="5229596268214362873">"Naršyklė"</string>
    <string name="cancel" msgid="3017274947407233702">"Atšaukti"</string>
    <string name="ok" msgid="1509280796718850364">"Gerai"</string>
    <string name="title_bar_loading" msgid="7438217780834640678">"Įkeliama…"</string>
    <string name="page_info" msgid="4048529256302257195">"Puslapio informacija"</string>
    <string name="page_info_view" msgid="5303490449842635158">"Žiūrėti puslapio informaciją"</string>
    <string name="page_info_address" msgid="2222306609532903254">"Adresas:"</string>
    <string name="ssl_warnings_header" msgid="79744901983636370">"Šioje svetainėje yra su saugos sertifikatu susijusių problemų."</string>
    <string name="ssl_continue" msgid="8031515015829358457">"Tęsti"</string>
    <string name="security_warning" msgid="6607795404322797541">"Saugos įspėjimas"</string>
    <string name="view_certificate" msgid="1472768887529093862">"Žiūrėti sertifikatą"</string>
    <string name="ssl_go_back" msgid="4598951822061593819">"Atgal"</string>
    <string name="ssl_untrusted" msgid="5369967226521102194">"Šį sertifikatą išdavė nepatikima įstaiga."</string>
    <string name="ssl_mismatch" msgid="558688832420069896">"Svetainės pavadinimas neatitinka sertifikate nurodyto pavadinimo."</string>
    <string name="ssl_expired" msgid="5739349389499575559">"Šio sertifikato galiojimo laikas baigėsi."</string>
    <string name="ssl_not_yet_valid" msgid="2893167846212645846">"Šis sertifikatas dar negalioja."</string>
    <string name="ssl_date_invalid" msgid="3705563379257285534">"Šio sertifikato data netinkama."</string>
    <string name="ssl_invalid" msgid="9041704741505449967">"Šis sertifikatas netinkamas."</string>
    <string name="ssl_unknown" msgid="5679243486524754571">"Nežinoma sertifikato klaida."</string>
    <string name="stopping" msgid="4839698519340302982">"Sustabdoma..."</string>
    <string name="stop" msgid="5687251076030630074">"Sustabdyti"</string>
    <string name="reload" msgid="8585220783228408062">"Atnaujinti"</string>
    <string name="back" msgid="8414603107175713668">"Atgal"</string>
    <string name="forward" msgid="4288210890526641577">"Persiųsti"</string>
    <string name="save" msgid="5922311934992468496">"Gerai"</string>
    <string name="do_not_save" msgid="6777633870113477714">"Atšaukti"</string>
    <string name="location" msgid="3411848697912600125">"Adresas"</string>
    <string name="account" msgid="5179824606448077042">"Paskyra"</string>
    <string name="containing_folder" msgid="6771180232953030479">"Pridėti prie"</string>
    <string name="new_folder" msgid="7743540149088867917">"Naujas aplankas"</string>
    <string name="edit_folder" msgid="621817453133656156">"Redaguoti aplanką"</string>
    <string name="delete_folder" msgid="2046483129024501116">"Ištrinti aplanką"</string>
    <string name="no_subfolders" msgid="5880411440592452802">"Nėra poaplankių"</string>
    <string name="add_to_bookmarks_menu_option" msgid="4449323955122214389">"Žymės"</string>
    <string name="add_to_homescreen_menu_option" msgid="1461447829242963790">"Pagrindinis ekranas"</string>
    <string name="add_to_other_folder_menu_option" msgid="5450890093372998187">"Kitas aplankas..."</string>
    <string name="name" msgid="5462672162695365387">"Etiketė"</string>
    <string name="http" msgid="2163722670597250102">"http://"</string>
    <string name="save_to_bookmarks" msgid="6101482434920313244">"Pridėti prie žymių"</string>
    <string name="bookmark_this_page" msgid="7530739804320811054">"Žymėti šį puslapį"</string>
    <string name="remove" msgid="7820112494467011374">"Pašalinti"</string>
    <string name="edit_bookmark" msgid="5024089053490231905">"Redaguoti žymę"</string>
    <string name="create_shortcut_bookmark" msgid="1995095662095484289">"Prie pagrindinio psl. pridėti spartųjį klavišą"</string>
    <string name="open_bookmark" msgid="8473581305759935790">"Atidaryti"</string>
    <string name="remove_bookmark" msgid="8407495852801410891">"Ištrinti žymę"</string>
    <string name="remove_from_bookmarks" msgid="4374080666576982775">"Pašalinti iš žymių"</string>
    <string name="remove_history_item" msgid="5021424935726728618">"Pašalinti iš istorijos"</string>
    <string name="set_as_homepage" msgid="4752937379414905560">"Nustatyti kaip pagrindinį puslapį"</string>
    <string name="bookmark_saved" msgid="2766434679871317557">"Išsaugota žymėse."</string>
    <string name="bookmark_not_saved" msgid="700600955089376724">"Neįmanoma išsaugoti žymės."</string>
    <string name="homepage_set" msgid="8768087280310966395">"Pagrindinis puslapis nustatytas."</string>
    <string name="bookmark_needs_title" msgid="6245900436119218187">"Žymė turi būti pavadinta."</string>
    <string name="bookmark_needs_url" msgid="7809876865972755158">"Žymė turi turėti vietą."</string>
    <string name="bookmark_url_not_valid" msgid="6719785633980202419">"Neteisingas URL."</string>
    <string name="bookmark_cannot_save_url" msgid="791722768778386941">"Negalima žymėti URL."</string>
    <string name="delete_bookmark" msgid="2422989994934201992">"Ištrinti"</string>
    <string name="bookmark_page" msgid="6845189305130307274">"Žymėti paskutinį peržiūrėtą puslapį"</string>
    <string name="bookmark_thumbnail_view" msgid="3164068314718522138">"Miniatiūros"</string>
    <string name="bookmark_list_view" msgid="7848510619500937839">"Sąrašas"</string>
    <string name="current_page" msgid="7510129573681663135">"nuo "</string>
    <string name="delete_bookmark_warning" msgid="758043186202032205">"Žymė „<xliff:g id="BOOKMARK">%s</xliff:g>“ bus ištrinta."</string>
    <string name="open_all_in_new_window" msgid="455786763426575293">"Atidaryti visas naujuose skirtukų lapuose"</string>
    <string name="goto_dot" msgid="3895839050522602723">"Pradėti"</string>
    <string name="select_dot" msgid="6299170761900561967">"Pasirinkti tekstą"</string>
    <string name="bookmarks" msgid="1961279134885867815">"Žymės"</string>
    <string name="shortcut_bookmark" msgid="3974876480401135895">"Žymė"</string>
    <string name="shortcut_bookmark_title" msgid="3072725276532691472">"Pasirinkite žymę"</string>
    <string name="history" msgid="2451240511251410032">"Istorija"</string>
    <string name="menu_view_download" msgid="2124570321712995120">"Atsisiuntimai"</string>
    <string name="copy_page_url" msgid="7635062169011319208">"Kopijuoti puslapio URL"</string>
    <string name="share_page" msgid="593756995297268343">"Bendrinti puslapį"</string>
    <string name="menu_save_snapshot" msgid="6935080344031126139">"Išsaugoti, kad būtų galima skaityti neprisijungus"</string>
    <string name="snapshot_failed" msgid="4584580873565876033">"Nepavyko išsaugoti, kad skaitytumėte neprisij."</string>
    <string name="contextheader_folder_bookmarkcount" msgid="353987136645619089">"Žymių: <xliff:g id="BOOKMARK_COUNT">%d</xliff:g>"</string>
    <string name="contextheader_folder_empty" msgid="974171637803391651">"Tuščias aplankas"</string>
    <string name="contextmenu_openlink" msgid="7237961252214188935">"Atidaryti"</string>
    <string name="contextmenu_openlink_newwindow" msgid="1205313604181761403">"Atidaryti naujame skirtuko lape"</string>
    <string name="contextmenu_openlink_newwindow_background" msgid="4690381019116746687">"Atidaryti naujame fono skirtuko lape"</string>
    <string name="contextmenu_savelink" msgid="5508554930832538184">"Išsaugoti nuorodą"</string>
    <string name="contextmenu_sharelink" msgid="5392275392280130331">"Bendrinti nuorodą"</string>
    <string name="contextmenu_copy" msgid="398860586635404030">"Kopijuoti"</string>
    <string name="contextmenu_copylink" msgid="5153657160294534270">"Kopijuoti nuorodos URL"</string>
    <string name="contextmenu_download_image" msgid="4243829645180686912">"Išsaugoti vaizdą"</string>
    <string name="contextmenu_view_image" msgid="3870625602053600905">"Žiūrėti vaizdą"</string>
    <string name="contextmenu_set_wallpaper" msgid="3691902960115350686">"Nustatyti kaip darbalaukio foną"</string>
    <string name="contextmenu_dial_dot" msgid="5856550683415933806">"Rinkti..."</string>
    <string name="contextmenu_add_contact" msgid="3183511922223645716">"Pridėti adresatą"</string>
    <string name="contextmenu_send_mail" msgid="1014513374828775660">"Siųsti el. laišką"</string>
    <string name="contextmenu_map" msgid="7471390435434034912">"Žemėlapis"</string>
    <string name="choosertitle_sharevia" msgid="4600490613341909086">"Bendrinti naudojant"</string>
    <string name="clear" msgid="7070043081700011461">"Išvalyti"</string>
    <string name="replace" msgid="4843033491070384047">"Pakeisti"</string>
    <string name="browser_bookmarks_page_bookmarks_text" msgid="6787605028726162673">"Žymės"</string>
    <string name="menu_preferences" msgid="6709237687234102240">"Nustatymai"</string>
    <string name="pref_content_title" msgid="722227111894838633">"Puslapio turinio nustatymai"</string>
    <string name="pref_content_load_images" msgid="2125616852957377561">"Įkelti vaizdus"</string>
    <string name="pref_content_load_images_summary" msgid="5055874125248398584">"Pateikti vaizdus tinklalapiuose"</string>
    <string name="pref_content_block_popups" msgid="4158524847764470895">"Blokuoti iššokanč. langus"</string>
    <string name="pref_content_javascript" msgid="4570972030299516843">"Įgalinti „JavaScript“"</string>
    <string name="pref_content_open_in_background" msgid="824123779725118663">"Atidaryti fone"</string>
    <string name="pref_content_plugins" msgid="7231944644794301582">"Įgalinti papildinius"</string>
  <string-array name="pref_content_plugins_choices">
    <item msgid="6745108155096660725">"Visada įjungta"</item>
    <item msgid="2484126708670016519">"Pareikalavus"</item>
    <item msgid="8547442717307793863">"Išjungta"</item>
  </string-array>
    <string name="pref_content_open_in_background_summary" msgid="6114922017800433172">"Atidaryti naujų skirtukų lapus už dabartinio"</string>
    <string name="pref_content_homepage" msgid="3324574611613105696">"Nustatyti pagrindinį puslapį"</string>
    <string name="pref_content_search_engine" msgid="1620101310821644144">"Nustatyti paieškos variklį"</string>
    <string name="pref_content_search_engine_summary" msgid="5162667665858487316">"Pasirinkti paieškos variklį"</string>
    <string name="pref_set_homepage_to" msgid="7196350233061395098">"Nustatyti…"</string>
  <string-array name="pref_homepage_choices">
    <item msgid="844041670142910837">"Dabartinis puslapis"</item>
    <item msgid="4430498748295169195">"Tuščias puslapis"</item>
    <item msgid="5747608191946904074">"Numatytasis puslapis"</item>
    <item msgid="6092441301001006473">"Dažniausiai lankomos svetainės"</item>
    <item msgid="5021822752506507426">"Kita…"</item>
  </string-array>
    <string name="pref_content_autofit" msgid="8260474534053660809">"Automatiškai talpinti puslapius"</string>
    <string name="pref_content_autofit_summary" msgid="4587831659894879986">"Formatuoti tinklalapius, kad tilptų ekrane"</string>
    <string name="pref_general_title" msgid="1946872771219249323">"Bendra"</string>
    <string name="pref_general_sync_title" msgid="3138637035975860324">"Sinchronizavimas"</string>
    <string name="pref_general_autofill_title" msgid="547881256865816858">"Automatinis pildymas"</string>
    <string name="pref_personal_sync_with_chrome" msgid="1695182180332194033">"Sinchronizuoti su „Google Chrome“"</string>
    <string name="pref_personal_sync_with_chrome_summary" msgid="7414133931827321055">"Bendrinti žymes ir kitus duomenis tarp „Android“ naršyklės ir „Google Chrome“"</string>
    <string name="pref_personal_google_account" msgid="952360133341490071">"„Google“ paskyra"</string>
    <string name="pref_personal_sync_bookmarks" msgid="59237515966184432">"Sinchronizuoti žymes"</string>
    <string name="pref_personal_sync_bookmarks_summary" msgid="4791767605662205482">"Sinchronizuoti žymes tarp „Android“ naršyklės ir „Google Chrome“"</string>
    <string name="pref_personal_start_syncing" msgid="6046972042512655232">"Pradėti sinchroniz."</string>
    <string name="pref_personal_account_dialog_title" msgid="1390867119887955530">"Pas. bendr. „Google“ pask."</string>
    <string name="pref_autofill_enabled" msgid="1015751713312396713">"Automatinis formos pildymas"</string>
    <string name="pref_autofill_enabled_summary" msgid="422640696197018914">"Vienu paspaudimu užpildykite žiniatinklio formas"</string>
    <string name="pref_autofill_profile_editor" msgid="3864116896052437796">"Automatinis duomenų pildymas"</string>
    <string name="pref_autofill_profile_editor_summary" msgid="3653552312512743181">"Įveskite duomenis ir išsaugokite juos automatinio pildymo formos žiniatinklyje laukuose"</string>
    <string name="pref_autologin_title" msgid="2362827272595366379">"Autom. prisijung. prie „Google“"</string>
    <string name="pref_autologin_progress" msgid="8333244467048833461">"Prisijungiama prie „Google“ svetainių naudojant <xliff:g id="ID_1">%s</xliff:g>"</string>
    <string name="autologin_bar_text" msgid="3684581827167173371">"Prisijungti kaip"</string>
    <string name="autologin_bar_login_text" msgid="3336615320510851879">"Prisij."</string>
    <string name="autologin_bar_hide_text" msgid="3629355974385859580">"Slėpti"</string>
    <string name="autologin_bar_error" msgid="7470001207395920811">"Nepavyko prisijungti."</string>
    <string name="autofill_profile_editor_heading" msgid="8392952553626722083">"Įveskite duomenis, kuriais norite automatiškai užpildyti žiniatinklio laukus, kai juos paliesite."</string>
    <string name="autofill_profile_editor_name" msgid="8566130291459685955">"Vardas ir pavardė:"</string>
    <string name="autofill_profile_editor_email_address" msgid="7967585896612797173">"El. paštas:"</string>
    <string name="autofill_profile_editor_company_name" msgid="2813443159949210417">"Įmonės pavadinimas:"</string>
    <string name="autofill_profile_editor_address_line_1" msgid="836433242509243081">"1 adreso eilutė:"</string>
    <string name="autofill_profile_editor_address_line_1_hint" msgid="5965659598509327172">"Adresas, pašto dėžutė, kilmės sertifikatas"</string>
    <string name="autofill_profile_editor_address_line_2" msgid="8194745202893822479">"2 adreso eilutė:"</string>
    <string name="autofill_profile_editor_address_line_2_hint" msgid="2048330295853546405">"Apartamentai, liukso kambariai, blokas, pastatas, aukštas ir kt."</string>
    <string name="autofill_profile_editor_city" msgid="4193225955409148508">"Miestas / miestelis:"</string>
    <string name="autofill_profile_editor_state" msgid="8549739922338171458">"Valstija / provincija / regionas:"</string>
    <string name="autofill_profile_editor_zip_code" msgid="283668573295656671">"Pašto kodas:"</string>
    <string name="autofill_profile_editor_country" msgid="7234470301239156656">"Šalis:"</string>
    <string name="autofill_profile_editor_phone_number" msgid="4938852821413729276">"Telefonas:"</string>
    <string name="autofill_profile_editor_phone_number_invalid" msgid="7166394872369167580">"Netinkamas telefono numeris"</string>
    <string name="autofill_profile_editor_save_profile" msgid="8349915287435262888">"Išsaugoti profilį"</string>
    <string name="autofill_profile_successful_save" msgid="6834102203944938409">"Profilis išsaugotas"</string>
    <string name="autofill_profile_successful_delete" msgid="2421442112954362732">"Profilis ištrintas"</string>
    <string name="autofill_profile_editor_delete_profile" msgid="2754563301088418752">"Ištrinti profilį"</string>
    <string name="autofill_setup_dialog_title" msgid="1955613311837926540">"Nustatyti automatinį pildymą?"</string>
    <string name="autofill_setup_dialog_message" msgid="6605682320156223114">"Naršyklė gali automatiškai užpildyti į šią panašias žiniatinklio formas. Ar norite nustatyti profilį?"</string>
    <string name="autofill_setup_dialog_negative_toast" msgid="6990737008936188620">"Automatinį pildymą visada galima konfigūruoti skiltyje „Naršyklės nustatymai“."</string>
    <string name="disable_autofill" msgid="8305901059849400354">"Neleisti automatinio pildymo"</string>
    <string name="pref_privacy_security_title" msgid="3480313968942160914">"Privatumas ir sauga"</string>
    <string name="pref_privacy_clear_cache" msgid="3380316479925886998">"Išvalyti talpyklą"</string>
    <string name="pref_privacy_clear_cache_summary" msgid="2216463577207991454">"Išvalyti vietinėje talpykloje saugomą turinį ir duomenis"</string>
    <string name="pref_privacy_clear_cache_dlg" msgid="5541011591300753881">"Vietinėje talpykloje saugomas turinys ir duomenys bus ištrinti."</string>
    <string name="pref_privacy_cookies_title" msgid="6763274282214830526">"Slapukai"</string>
    <string name="pref_privacy_clear_cookies" msgid="3095583579133780331">"Išvalyti visus slapukų duomenis"</string>
    <string name="pref_privacy_clear_cookies_summary" msgid="6962742063990677520">"Išvalyti visus naršyklės slapukus"</string>
    <string name="pref_privacy_clear_cookies_dlg" msgid="552855688091432682">"Bus ištrinti visi slapukai."</string>
    <string name="pref_privacy_clear_history" msgid="8723795508825198477">"Išvalyti istoriją"</string>
    <string name="pref_privacy_clear_history_summary" msgid="6868501330708940734">"Išvalyti naršyklės naršymo istoriją"</string>
    <string name="pref_privacy_clear_history_dlg" msgid="544903007914753853">"Bus ištrinta naršyklės navigacijos istorija."</string>
    <string name="pref_privacy_formdata_title" msgid="6549813837982050424">"Formos duomenys"</string>
    <string name="pref_privacy_clear_form_data" msgid="4232668196344383987">"Išvalyti formos duomenis"</string>
    <string name="pref_privacy_clear_form_data_summary" msgid="1790390894719517167">"Išvalyti visus išsaugotus formos duomenis"</string>
    <string name="pref_privacy_clear_form_data_dlg" msgid="4443621086781197928">"Bus ištrinti visi išsaugoti formos duomenys."</string>
    <string name="pref_privacy_clear_passwords" msgid="4750234112289277480">"Išvalyti slaptažodžius"</string>
    <string name="pref_privacy_clear_passwords_summary" msgid="8856782718942903335">"Išvalyti visus išsaugotus slaptažodžius"</string>
    <string name="pref_privacy_clear_passwords_dlg" msgid="2083869328824248255">"Visi išsaugoti slaptažodžiai bus ištrinti."</string>
    <string name="pref_privacy_location_title" msgid="7458378016606081067">"Vieta"</string>
    <string name="pref_privacy_enable_geolocation" msgid="1395040170290765686">"Įgalinti vietą"</string>
    <string name="pref_privacy_enable_geolocation_summary" msgid="8437020934664306205">"Leisti svetainėms teikti užklausas dėl prieigos prie jūsų vietovės"</string>
    <string name="pref_privacy_clear_geolocation_access" msgid="6649680770030042980">"Išvalyti prieigą prie vietos"</string>
    <string name="pref_privacy_clear_geolocation_access_summary" msgid="7750143359497314679">"Išvalyti visų svetainių vietų prieigą"</string>
    <string name="pref_privacy_clear_geolocation_access_dlg" msgid="7327063124488827244">"Išvalyti visų svetainių vietų prieigą"</string>
    <string name="pref_security_passwords_title" msgid="5734190542383756711">"Slaptažodžiai"</string>
    <string name="pref_security_remember_passwords" msgid="6492957683454529549">"Atsiminti slaptažodžius"</string>
    <string name="pref_security_remember_passwords_summary" msgid="256388703356349137">"Išsaugoti svetainių naudotojų vardus ir slaptažodžius"</string>
    <string name="pref_security_save_form_data" msgid="1213669802810198893">"Atsiminti formos duomenis"</string>
    <string name="pref_security_save_form_data_summary" msgid="4994074685153708026">"Atsiminti duomenis, kuriuos įvedu į formas, kad vėliau būtų galima jas naudoti"</string>
    <string name="pref_security_show_security_warning" msgid="8901135676266754559">"Rodyti saugos įspėjimus"</string>
    <string name="pref_security_show_security_warning_summary" msgid="8968906112720511704">"Rodyti įspėjimą, jei kyla problemų dėl svetainės saugos"</string>
    <string name="pref_security_accept_cookies" msgid="3201367661925047989">"Priimti slapukus"</string>
    <string name="pref_security_accept_cookies_summary" msgid="1465118934875026920">"Leisti svetainėms išsaugoti ir skaityti „slapukų“ duomenis"</string>
  <string-array name="pref_text_size_choices">
    <item msgid="4952686548944739548">"Labai nedidelis"</item>
    <item msgid="1950030433642671460">"Mažas"</item>
    <item msgid="4338347520133294584">"Įprastas"</item>
    <item msgid="5043128215356351184">"Didelis"</item>
    <item msgid="7201512237890458902">"Didžiulis"</item>
  </string-array>
    <string name="pref_min_font_size" msgid="8811125835817449131">"Mažiausias šrifto dydis"</string>
    <string name="pref_min_font_size_value" msgid="2924708480509060209">"<xliff:g id="FONT_SIZE">%d</xliff:g> tašk."</string>
    <string name="pref_text_zoom" msgid="8387229123479610157">"Teksto mastelio keitimas"</string>
    <string name="pref_force_userscalable" msgid="5641500562399892621">"Priverstinai įgal. mast. keit."</string>
    <string name="pref_force_userscalable_summary" msgid="4431962409438162448">"Ar įr. svet. užkl. vald. mast. keit. elgs."</string>
    <string name="pref_inverted_category" msgid="3115731672066279347">"Atvirkštinis ekrano atvaizdavimas"</string>
    <string name="pref_inverted" msgid="4813962104859359420">"Atvirkštinis atvaizdavimas"</string>
    <string name="pref_inverted_summary" msgid="8570087335228699813">"Įgalinti atvirkštinį atvaizdavimą. Juoda taps balta ir atvirkščiai."</string>
    <string name="pref_inverted_contrast" msgid="8527441236225288169">"Kontrastas"</string>
    <string name="pref_default_zoom" msgid="8076142259097187395">"Numatytasis mastelio keitimas"</string>
  <string-array name="pref_default_zoom_choices">
    <item msgid="549583171195154919">"Toli"</item>
    <item msgid="5619034257768161024">"Vidutinis"</item>
    <item msgid="3840999588443167001">"Uždaryti"</item>
  </string-array>
    <string name="pref_default_zoom_dialogtitle" msgid="6095974367125109021">"Numatytasis mastelio keitimas"</string>
    <string name="pref_content_load_page" msgid="2219810141690955452">"Atidaryti puslapius apžvalgai"</string>
    <string name="pref_content_load_page_summary" msgid="8792093504054149369">"Rodyti naujai atidarytų puslapių apžvalgas"</string>
    <string name="pref_extras_title" msgid="7075456173747370647">"Išplėstinis"</string>
    <string name="pref_extras_website_settings" msgid="67866640052455549">"Svetainės nustatymai"</string>
    <string name="pref_extras_website_settings_summary" msgid="1656771443223494406">"Išplėstiniai atskirų svetainių nustatymai"</string>
    <string name="pref_extras_reset_default_title" msgid="3579760449455761762">"Iš naujo nustatyti numatytuosius nustatymus"</string>
    <string name="pref_extras_reset_default" msgid="8904000515846202110">"Nustatyti iš naujo į numatytuosius nustatymus"</string>
    <string name="pref_extras_reset_default_summary" msgid="4247870778270414501">"Atkurti numatytuosius nustatymus"</string>
    <string name="pref_extras_reset_default_dlg" msgid="6640261575874704022">"Nustatymai bus grąžinti į numatytąsias vertes."</string>
    <string name="pref_extras_reset_default_dlg_title" msgid="2250334970728938936">"Nustatyti iš naujo į numatytuosius nustatymus"</string>
    <string name="pref_development_title" msgid="3263854204533056480">"Derinti"</string>
    <string name="pref_default_text_encoding" msgid="5742965543955558478">"Teksto koduotė"</string>
  <string-array name="pref_default_text_encoding_choices">
    <item msgid="7275223955790513818">"Lotynų-1 (ISO-8859-1)"</item>
    <item msgid="2456597866837587140">"Unikodas (UTF-8)"</item>
    <item msgid="6122474363777211732">"Kinų (GBK)"</item>
    <item msgid="373372275931607040">"Kinų (Big5)"</item>
    <item msgid="891615911084608570">"Japonų (ISO-2022-JP)"</item>
    <item msgid="5589150448475151241">"Japonų (SHIFT_JIS)"</item>
    <item msgid="7356792686950371843">"Japonų (EUC-JP)"</item>
    <item msgid="2193955365569270096">"Korėjiečių (EUC-KR)"</item>
  </string-array>
    <string name="pref_default_text_encoding_dialogtitle" msgid="5508255018084978547">"Teksto koduotė"</string>
    <string name="pref_accessibility_title" msgid="5127836981587423215">"Pasiekiamumas"</string>
    <string name="pref_font_size_category" msgid="6288925476811083551">"Šrifto dydis"</string>
    <string name="pref_lab_title" msgid="5571091610359629423">"Laboratorijos"</string>
    <string name="pref_lab_quick_controls" msgid="3267606522082281367">"Spartieji valdikliai"</string>
    <string name="pref_lab_quick_controls_summary" msgid="1564546156544675707">"Sl. nykščiu iš kair. ar deš. kr., kad pasiekt. sparč. vald. ir pasl. pr. ir URL juost."</string>
    <string name="pref_use_instant_search" msgid="1119176077760723740">"Intuityvioji „Google“ paieška"</string>
    <string name="pref_use_instant_search_summary" msgid="839320474961917522">"Kai naud. „Google“ paiešką, naud. Int. „Google“ paiešką, kad renk. tekst. b. rodomi rezult. (tai g. padid. duom. naud.)."</string>
    <string name="pref_lab_fullscreen" msgid="8173609016657987973">"Visas ekranas"</string>
    <string name="pref_lab_fullscreen_summary" msgid="6853711692160711419">"Jei norite paslėpti būsenos juostą, naudokite viso ekrano režimą."</string>
    <string name="pref_data_title" msgid="750316606686075162">"Pralaidumo valdymas"</string>
    <string name="pref_data_preload_title" msgid="4479320472980292873">"Iš anksto įkeliamas paieškos rezultatas"</string>
    <string name="pref_data_preload_summary" msgid="7488335627364473744">"Leisti naršyklei fone iš anksto įkelti itin patikimus paieškos rezultatus"</string>
    <string name="browserFrameNetworkErrorLabel" msgid="126892350904924893">"Duomenų jungiamumo problema"</string>
    <string name="browserFrameFileErrorLabel" msgid="8063691502792670367">"Failo problema"</string>
    <string name="browserFrameFormResubmitLabel" msgid="2685923472682180360">"Patvirtinti"</string>
    <string name="browserFrameFormResubmitMessage" msgid="2752182215695632138">"Puslapyje, kurį bandote peržiūrėti, yra duomenų, kurie jau pateikti (POSTDATA). Jei duomenis siųsite iš naujo, bus pakartoti visi puslapyje esančioje formoje nurodyti veiksmai (pvz., paieška ar pirkimas internetu)."</string>
    <string name="loadSuspendedTitle" msgid="675991625288706944">"Nėra tinklo ryšio"</string>
    <string name="loadSuspended" msgid="3133656588880851273">"Naršyklė negali įkelti šio puslapio, nes nėra interneto ryšio."</string>
    <string name="clear_history" msgid="5998307092715979619">"Išvalyti istoriją"</string>
    <string name="browser_history" msgid="1038987118290272525">"Paskutiniai lankyti puslapiai"</string>
    <string name="empty_history" msgid="8738772352308207274">"Naršyklės istorija tuščia."</string>
    <string name="go_home" msgid="3140773562046381164">"Pagrindinis puslapis"</string>
    <string name="add_new_bookmark" msgid="8086367791400349049">"Pridėti žymę..."</string>
    <string name="add_bookmark_short" msgid="3783984330998103735">"Pridėti"</string>
    <string name="search_hint" msgid="4647356319916631820">"Ieškokite ar įveskite URL"</string>
    <string name="search_button_text" msgid="5235226933877634410">"Pradėti"</string>
    <string name="search_settings_description" msgid="1422401062529014107">"Žymės ir žiniatinklio istorija"</string>
    <string name="attention" msgid="3473639060042811244">"Dėmesio"</string>
    <string name="popup_window_attempt" msgid="2673111696288657989">"Ši svetainė bando atidaryti iššokantįjį langą."</string>
    <string name="allow" msgid="1157313689171991335">"Leisti"</string>
    <string name="block" msgid="9172175889884707800">"Blokuoti"</string>
    <string name="too_many_windows_dialog_title" msgid="5709782301477380438">"Pasiekta skirtukų riba"</string>
    <string name="too_many_windows_dialog_message" msgid="7417529754382308997">"Nepavyko atidaryti naujo skirtuko lapo, nes jau pasiekėte maksimalų skaičių."</string>
    <string name="too_many_subwindows_dialog_title" msgid="3805453941587725944">"Iššokantysis langas jau atidarytas"</string>
    <string name="too_many_subwindows_dialog_message" msgid="5827289829907966657">"Nepavyko atidaryti naujo iššokančiojo lango, nes vienu metu gali būti atidarytas tik vienas langas."</string>
    <string name="download_title" msgid="2122874021047565594">"Atsisiuntimo istorija"</string>
    <string name="download_unknown_filename" msgid="4013465542563652175">"&lt;Nežinomas&gt;"</string>
    <string name="download_menu_open" msgid="4888327480367757513">"Atidaryti"</string>
    <string name="download_menu_clear" msgid="6264454531553418124">"Išvalyti iš sąrašo"</string>
    <string name="download_menu_delete" msgid="8815502136393894148">"Ištrinti"</string>
    <string name="download_menu_cancel" msgid="2545333007601851574">"Atšaukti atsisiuntimą"</string>
    <string name="download_menu_cancel_all" msgid="2136550823151999166">"Atšaukti visus atsisiuntimus"</string>
    <string name="download_cancel_dlg_title" msgid="8909108500262799748">"Atšaukti atsisiuntimus"</string>
    <string name="download_cancel_dlg_msg" msgid="6285389170052357797">"Visi <xliff:g id="DOWNLOAD_COUNT">%d</xliff:g> atsisiuntimai (-ų) bus atšaukti (-a) ir išvalyti (-a) iš atsisiuntimo istorijos."</string>
    <string name="download_delete_file" msgid="5330036497843073249">"Failas bus ištrintas"</string>
    <string name="download_file_error_dlg_title" msgid="2693630283595384874">"Nėra vietos"</string>
    <string name="download_file_error_dlg_msg" msgid="5156405410324072471">"Nepavyko atsisiųsti <xliff:g id="FILENAME">%s</xliff:g>."\n"Atlaisvinkite vietos telefone ir bandykite dar kartą."</string>
    <string name="download_failed_generic_dlg_title" msgid="6106781095337833391">"Atsisiuntimas nesėkmingas"</string>
    <string name="download_no_sdcard_dlg_title" product="nosdcard" msgid="56777245081568508">"USB atmintinė nepasiekiama"</string>
    <string name="download_no_sdcard_dlg_title" product="default" msgid="605904452159416792">"Nėra SD kortelės"</string>
    <string name="download_no_sdcard_dlg_msg" product="nosdcard" msgid="3144652102051031721">"Į USB atmintinę reikia atsisiųsti <xliff:g id="FILENAME">%s</xliff:g>."</string>
    <string name="download_no_sdcard_dlg_msg" product="default" msgid="2616399456116301518">"Norint atsisiųsti <xliff:g id="FILENAME">%s</xliff:g>, reikalinga SD kortelė."</string>
    <string name="download_sdcard_busy_dlg_title" product="nosdcard" msgid="8081445664689818973">"USB atmintinė nepasiekiama"</string>
    <string name="download_sdcard_busy_dlg_title" product="default" msgid="6877712666046917741">"SD kortelė negalima"</string>
    <string name="download_sdcard_busy_dlg_msg" product="nosdcard" msgid="3979329954835690147">"USB atmintinė užimta. Jei norite leisti atsisiuntimus, pranešime pasirinkite „Išjungti USB atmintinę“."</string>
    <string name="download_sdcard_busy_dlg_msg" product="default" msgid="3473883538192835204">"SD kortelė užimta. Jei norite leisti atsisiuntimus, pranešime pasirinkite „Išjungti USB saugyklą“."</string>
    <string name="cannot_download" msgid="8150552478556798780">"Galima atsisiųsti tik „http“ ar „https“ prasidedančius URL."</string>
    <string name="download_no_application_title" msgid="1286056729168874295">"Nepavyksta atidaryti failo"</string>
    <string name="retry" msgid="1835923075542266721">"Bandyti dar kartą"</string>
    <string name="no_downloads" msgid="3947445710685021498">"Atsisiuntimo istorija tuščia."</string>
    <string name="download_error" msgid="413496839831257187">"Atsisiuntimas nesėkmingas."</string>
    <string name="download_success" msgid="2279041638155595203">"<xliff:g id="FILE">%s</xliff:g> atsisiuntimas baigtas."</string>
    <string name="download_running" msgid="2622942231322015059">"Atsisiunčiama..."</string>
    <string name="download_pending" msgid="2599683668575349559">"Pradedamas atsisiuntimas..."</string>
    <string name="download_pending_network" msgid="6548714525679461053">"Laukiama duomenų ryšio..."</string>
    <string name="download_running_paused" msgid="6418029352085656495">"Laukiama duomenų ryšio..."</string>
    <string name="download_canceled" msgid="6057083743144492515">"Atsisiuntimas atšauktas."</string>
    <string name="download_not_acceptable" msgid="313769696131563652">"Negalima atsisiųsti. Turinys šiame telefone nepalaikomas."</string>
    <string name="download_file_error" msgid="1206648050615176113">"Nepavyko užbaigti atsisiuntimo. Nepakanka vietos."</string>
    <string name="download_length_required" msgid="9038605488460437406">"Nepavyksta atsisiųsti. Negalima nustatyti elemento dydžio."</string>
    <string name="download_precondition_failed" msgid="8327584102874295580">"Atsisiuntimas pertrauktas. Jo atnaujinti negalima."</string>
    <string name="search_the_web" msgid="6046130189241962337">"Ieškoti žiniatinklyje"</string>
    <string name="webstorage_outofspace_notification_title" msgid="1160474608059771788">"Naršyklės saugykla pilna"</string>
    <string name="webstorage_outofspace_notification_text" msgid="7341075135051829692">"Spustelėkite, jei norite atlaisvinti vietos."</string>
    <string name="webstorage_clear_data_title" msgid="689484577124333977">"Išvalyti išsaugotus duomenis"</string>
    <string name="webstorage_clear_data_dialog_title" msgid="345457466368974706">"Išvalyti išsaugotus duomenis"</string>
    <string name="webstorage_clear_data_dialog_message" msgid="6678281256970470125">"Visi šioje svetainėje saugomi duomenys bus ištrinti"</string>
    <string name="webstorage_clear_data_dialog_ok_button" msgid="2516563534211898636">"Išvalyti viską"</string>
    <string name="webstorage_clear_data_dialog_cancel_button" msgid="2028867751958942762">"Atšaukti"</string>
    <string name="webstorage_origin_summary_mb_stored" msgid="1985885826292236210">"Jūsų telefone išsaugota MB"</string>
    <string name="loading_video" msgid="4887871585216091096">"Įkeliamas vaizdo įrašas"</string>
    <string name="geolocation_permissions_prompt_message" msgid="356796102004052471">"<xliff:g id="WEBSITE_ORIGIN">%s</xliff:g> nori žinoti jūsų vietą"</string>
    <string name="geolocation_permissions_prompt_share" msgid="9084486342048347976">"Bendrinti vietą"</string>
    <string name="geolocation_permissions_prompt_dont_share" msgid="6303025160237860300">"Atmesti"</string>
    <string name="geolocation_permissions_prompt_remember" msgid="3118526300707348308">"Atsiminti nuostatą"</string>
    <!-- outdated translation 987286072035125498 -->     <string name="geolocation_permissions_prompt_toast_allowed" msgid="7833771073195530638">"Ši svetainė gali pasiekti jūsų vietos. Pakeiskite tai apsilankę „Nustatymai“ -&gt; „Svetainės nustatymai“"</string>
    <!-- outdated translation 7695100950212692515 -->     <string name="geolocation_permissions_prompt_toast_disallowed" msgid="7418225389343746465">"Ši svetainė negali pasiekti jūsų vietos. Pakeiskite tai apsilankę „Nustatymai“ -&gt; „Svetainės nustatymai“"</string>
    <string name="geolocation_settings_page_title" msgid="1745477985097536528">"Išvalyti prieigą prie vietos"</string>
    <string name="geolocation_settings_page_summary_allowed" msgid="9180251524290811398">"Šiuo metu ši svetainė gali pasiekti jūsų vietą"</string>
    <string name="geolocation_settings_page_summary_not_allowed" msgid="4589649082203102544">"Ši svetainė dabar negali pasiekti jūsų vietos"</string>
    <string name="geolocation_settings_page_dialog_title" msgid="1549842043381347668">"Išvalyti prieigą prie vietos"</string>
    <string name="geolocation_settings_page_dialog_message" msgid="7586671987576403993">"Vietos prieiga šiai svetainei bus ištrinta"</string>
    <string name="geolocation_settings_page_dialog_ok_button" msgid="4789434178048077287">"Išvalyti prieigą"</string>
    <string name="geolocation_settings_page_dialog_cancel_button" msgid="7941036504673409747">"Atšaukti"</string>
    <string name="website_settings_clear_all" msgid="8739804325997655980">"Išvalyti viską"</string>
    <string name="website_settings_clear_all_dialog_title" msgid="7791826325122461718">"Išvalyti visus svetainės nustatymus?"</string>
    <string name="website_settings_clear_all_dialog_message" msgid="6150502090601476333">"Bus ištrinti visi svetainės duomenys ir vietų leidimai."</string>
    <string name="website_settings_clear_all_dialog_ok_button" msgid="6401582240627669431">"Ištrinti visus duomenis"</string>
    <string name="website_settings_clear_all_dialog_cancel_button" msgid="1896757051856611674">"Atšaukti"</string>
    <string name="progress_dialog_setting_wallpaper" msgid="4871900779338536674">"Nustatomas darbalaukio fonas..."</string>
    <string name="defaultBookmarksUpButton" msgid="2303951020715704735">"Žymės"</string>
    <string name="empty_bookmarks_folder" msgid="7843361614634930942">"Nėra žymių"</string>
    <string name="rlz_access_point" msgid="7165847807377650632">"Y1"</string>
    <string name="account_chooser_dialog_title" msgid="3314204833188808194">"Pasirinkite paskyrą"</string>
    <string name="import_bookmarks_dialog_title" msgid="3325557652271172128">"Sinchron. su „Google“ paskyra"</string>
    <string name="import_bookmarks_dialog_description" msgid="1942452375564381488">"Šiame įrenginyje esančios žymės dar nesusietos su „Google“ paskyra. Išsaugokite šias žymes pridėdami jas prie paskyros. Jei nenorite žymių sinchronizuoti, ištrinkite jas."</string>
    <string name="import_bookmarks_dialog_select_add_account" msgid="3102882579089291099">"Pridėti šiuo metu šiame įrenginyje esančias žymes ir pradėti sinchronizavimą su „Google“ paskyra"</string>
    <string name="import_bookmarks_dialog_delete_select_account" msgid="5192284761080626386">"Ištrinti šiuo metu šiame įrenginyje esančias žymes ir pradėti sinchronizavimą su „Google“ paskyra"</string>
    <string name="import_bookmarks_dialog_confirm_delete" msgid="8854001080444749211">"Ištrinti šiuo metu šiame įrenginyje esančias žymes ir pradėti žymių sinchronizavimą su <xliff:g id="GOOGLE_ACCOUNT">%s</xliff:g>."</string>
    <string name="import_bookmarks_dialog_confirm_add" msgid="5433677293195372675">"Pridėti šiuo metu šiame įrenginyje esančias žymes ir pradėti žymių sinchronizavimą su <xliff:g id="GOOGLE_ACCOUNT">%s</xliff:g>."</string>
    <string name="import_bookmarks_dialog_remove" msgid="5984607822851800902">"Ištrinti žymes"</string>
    <string name="import_bookmarks_wizard_next" msgid="7578143961884352676">"Kitas"</string>
    <string name="import_bookmarks_wizard_previous" msgid="8551440353688257031">"Ankstesnis"</string>
    <string name="import_bookmarks_wizard_cancel" msgid="4936061122806506634">"Atšaukti"</string>
    <string name="import_bookmarks_wizard_done" msgid="1446247092194489191">"Atlikta"</string>
    <string name="import_bookmarks_dialog_add" msgid="7552306756868669353">"Pridėti žymių prie „Google“ paskyros"</string>
    <string name="import_bookmarks_dialog_import" msgid="6933613853573899218">"Pridėkite „Android“ žymes prie <xliff:g id="GOOGLE_ACCOUNT">%s</xliff:g> žymių"</string>
    <string name="menu_share_url" msgid="5851814357333739700">"Bendrinti"</string>
    <string name="max_tabs_warning" msgid="4122034303809457570">"Daugiau galimų skirtukų nėra"</string>
    <string name="instant_search_label" msgid="8769284297650716935">"„Google“ su Intuityviąja paieška (Laboratorijos)"</string>
    <string name="preview" msgid="6450823514561689038">"Peržiūra"</string>
    <string name="local_bookmarks" msgid="533816851415228520">"Vietinės"</string>
    <string name="ua_switcher_desktop" msgid="220097077327558435">"Pateikti užkl. dėl svetainės versijos kompiut."</string>
    <string name="permission_preload_label" msgid="4856971662337877316">"Iš anksto įkelti rezultatus"</string>
    <string name="empty_snapshots_folder" msgid="5788256228290785444">"Nėra išsaugotų puslapių."</string>
    <string name="remove_snapshot" msgid="1624447424544976849">"Ištrinti išsaugotą puslapį"</string>
    <string name="snapshot_go_live" msgid="1209542802541168497">"Transl. tiesiogiai"</string>
    <string name="accessibility_button_back" msgid="6194680634245279407">"Grįžti"</string>
    <string name="accessibility_button_forward" msgid="1236827218480658168">"Eiti pirmyn"</string>
    <string name="accessibility_button_refresh" msgid="1023441396241841313">"Atnaujinti puslapį"</string>
    <string name="accessibility_button_stop" msgid="6793644120043222148">"Sustabdyti puslapio įkėlimą"</string>
    <string name="accessibility_button_addbookmark" msgid="4787844912630006181">"Žymėti puslapį"</string>
    <string name="accessibility_button_search" msgid="5357014102136055376">"Ieškoti"</string>
    <string name="accessibility_button_voice" msgid="152016375096083337">"Pradėti paiešką balsu"</string>
    <string name="accessibility_button_bookmarks" msgid="7435055677299151649">"Žymės"</string>
    <string name="accessibility_button_closetab" msgid="6954807842756927737">"Uždaryti skirtuką"</string>
    <string name="accessibility_button_newtab" msgid="4116986240706315748">"Atidaryti naują skirtuką"</string>
    <string name="accessibility_button_newincognitotab" msgid="5254901889040012964">"Atidaryti naują inkognito skirtuką"</string>
    <string name="accessibility_button_clear" msgid="6943152307986161598">"Išvalyti įvestą tekstą"</string>
    <string name="accessibility_button_uaswitch" msgid="6286804719724282339">"Perjungti naudotojo priemonę"</string>
    <string name="accessibility_button_go" msgid="1182818872083055958">"Pirmyn"</string>
    <string name="accessibility_button_navscreen" msgid="9142904748728713075">"Puslapių tvarkyklė"</string>
    <string name="accessibility_button_more" msgid="3054251446394224216">"Daugiau parinkčių"</string>
    <string name="accessibility_state_incognito" msgid="5786038488425202355">"Inkognito puslapis"</string>
    <string name="accessibility_state_frozen" msgid="8041539250447035570">"Išsaugotas puslapis"</string>
    <string name="accessibility_transition_navscreen" msgid="2734915619351519547">"Skirtuko valdymas"</string>
</resources>
