<?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">"Áno"</string>
    <string name="no" msgid="5541738710521607130">"Nie"</string>
    <string name="create" msgid="986997212165228751">"Vytvoriť"</string>
    <string name="allow" msgid="3763244945363657722">"Povoliť"</string>
    <string name="deny" msgid="7326117222944479942">"Zamietnuť"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Zapnúť"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Neznáme"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="1646187747875476269">
      <item quantity="few">Ešte <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> kroky a bude z vás vývojár.</item>
      <item quantity="many">Ešte <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> kroka a bude z vás vývojár.</item>
      <item quantity="other">Ešte <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> krokov a bude z vás vývojár.</item>
      <item quantity="one">Ešte <xliff:g id="STEP_COUNT_0">%1$d</xliff:g> krok a bude z vás vývojár.</item>
    </plurals>
    <string name="show_dev_on" msgid="2840850085134853754">"Teraz ste vývojár!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Nie je to potrebné, už ste vývojár."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Najprv povoľte možnosti pre vývojárov"</string>
    <string name="header_category_wireless_networks" msgid="303445626075235229">"Bezdrôtové pripojenia a siete"</string>
    <string name="header_category_system" msgid="1665516346845259058">"Systém"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"V prevádzke"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Mimo prevádzky"</string>
    <string name="radioInfo_service_emergency" msgid="6838935881091760942">"Len tiesňové volania"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Rádio je vypnuté"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Bez roamingu"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Odpojený"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Pripája sa"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Pripojené"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Pozastavená"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Neznáme"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="1816306320988638382">"Odpoj. uklad. priestor USB"</string>
    <string name="sdcard_unmount" product="default" msgid="8078570285871053815">"Odpojiť SD kartu"</string>
    <string name="sdcard_format" product="nosdcard" msgid="3248760426252305366">"Vymazať ukladací priestor USB"</string>
    <string name="sdcard_format" product="default" msgid="3676635435136326182">"Vymazať SD kartu"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Ukážka"</string>
    <string name="preview_page_indicator_content_description" msgid="2790254666634885865">"Zobraziť ukážku stránky <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> z <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="font_size_summary" msgid="1296835853522566260">"Zväčšite alebo zmenšite text na obrazovke."</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Zmenšiť"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Zväčšiť"</string>
    <string name="font_size_preview_text_headline" msgid="1173103737980511652">"Ukážkový text"</string>
    <string name="font_size_preview_text_title" msgid="6363561029914452382">"Čarodejník z krajiny Oz"</string>
    <string name="font_size_preview_text_subtitle" msgid="5806349524325544614">"11. kapitola: Nádherné smaragdové mesto"</string>
    <string name="font_size_preview_text_body" msgid="3323732544011097199">"Lesk tohto nádherného mesta Dorotku a jej priateľov najskôr oslepoval, hoci mali na očiach zelené okuliare. Ulice lemovali nádherné domy zo zeleného mramoru, husto osadené trblietajúcimi sa smaragdmi. Kráčali po chodníku z takého istého zeleného mramoru. Na miestach, kde sa spájali dlaždice, sa ligotali v odraze slnka husté rady smaragdov. Obločné tabule boli zo zeleného skla. Dokonca aj obloha nad mestom bola zafarbená dozelena a slnečné lúče boli tiež zelené. \n\nV uliciach bolo veľa ľudí. Muži, ženy i deti si vykračovali oblečení v zelených šatách a všetci mali zelenkavú pokožku. Zvedavo si obzerali Dorotku a jej prazvláštnu spoločnosť. Keď deti zbadali leva, rýchlo utiekli a skryli sa za matkin chrbát. Nik sa však Dorotke a jej spoločníkom neprihovoril. Na ulici bolo mnoho rozličných obchodov. Dorotkinmu zraku neušlo, že všetok tovar bol zelený. Zelené cukríky, zelené pukance, zelené topánky, zelené klobúky a všelijaké zelené šaty – to všetko tu bolo na predaj. Jeden obchodník predával zelenú limonádu. Keď si ju deti kupovali, Dorotka zbadala, že platia zelenými mincami. \n\nZdalo sa, že sa v meste nenachádzajú žiadne kone ani iné zvieratá. Muži tlačili pred sebou malé zelené vozíky, v ktorých prevážali veci, kam bolo treba. Všetci vyzerali šťastní, spokojní a prekvitajúci."</string>
    <string name="font_size_save" msgid="206892409190870726">"OK"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="6071836464978826249">"Ukladací priestor USB"</string>
    <string name="sdcard_setting" product="default" msgid="3713462184783824923">"SD karta"</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Viditeľné pre všetky okolité zariadenia Bluetooth (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Viditeľné pre všetky okolité zariadenia Bluetooth"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Neviditeľné pre ostatné zariadenia Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Viditeľné len pre spárované zariadenia"</string>
    <string name="bluetooth_visibility_timeout" msgid="7611781967900196353">"Časový limit viditeľnosti"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="7405038248936935186">"Uzamknúť hlasové vytáčanie"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4959591522483403402">"Zabrániť použitiu vytáčania Bluetooth pri uzamknutej obrazovke"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Zariadenia Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Názov zariadenia"</string>
    <string name="bluetooth_device_details" msgid="630702184344217832">"Nastavenia zariadenia"</string>
    <string name="bluetooth_profile_details" msgid="1269419918127093325">"Nastavenia profilu"</string>
    <string name="bluetooth_name_not_set" msgid="4654357917928126208">"Názov nie je nastavený, použije sa názov účtu"</string>
    <string name="bluetooth_scan_for_devices" msgid="8143654526358934069">"Vyhľadať zariadenia"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Premenovať toto zariadenie"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Premenovať"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Odpojiť zariadenie?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="1934297101665686854">"Váš telefón sa odpojí od zariadenia <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="tablet" msgid="336622948210457991">"Váš tablet sa odpojí od zariadenia <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="device" msgid="6944790936166852428">"Vaše zariadenie sa odpojí od zariadenia <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="4173740094381092185">"Odpojiť"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="909734990821975673">"Nemáte povolenie na zmenu nastavení Bluetooth."</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Spárovať nové zariadenie"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_is_visible_message" msgid="3811631869768157387">"Pri otvorených nastaveniach Bluetooth je zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> viditeľné pre zariadenia v okolí."</string>
    <string name="bluetooth_footer_mac_message" product="default" msgid="4782330594323261630">"Adresa Bluetooth telefónu: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="tablet" msgid="1257226691967432025">"Adresa Bluetooth tabletu: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="device" msgid="2863536947810007600">"Adresa Bluetooth zariadenia: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_is_disconnect_question" msgid="777406775955421784">"Odpojiť zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="6379176741690311973">"Vysielanie"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Nepomenované zariadenie s rozhraním Bluetooth"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Vyhľadávanie"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"V okolí nie sú žiadne zariadenia Bluetooth."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Žiadosť o párovanie zariadenia Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Žiadosť na párovanie"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> spárujete klepnutím."</string>
    <string name="bluetooth_show_received_files" msgid="685424727760622632">"Prijaté súbory"</string>
    <string name="bluetooth_show_files_received_via_bluetooth" msgid="7097860463458492953">"Súbory prijaté cez Bluetooth"</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Rozhranie Bluetooth je vypnuté"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Zapnite ho klepnutím"</string>
    <string name="device_picker" msgid="2427027896389445414">"Vybrať zariadenie Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnúť Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce vypnúť Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Aplikácia chce zapnúť Bluetooth."</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Aplikácia chce vypnúť Bluetooth"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="1273405567801929487">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce na <xliff:g id="TIMEOUT">%2$d</xliff:g> s prepnúť tablet do režimu, v ktorom bude viditeľný pre ostatné zariadenia Bluetooth."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="7013223328571883275">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce na <xliff:g id="TIMEOUT">%2$d</xliff:g> s prepnúť telefón do režimu, v ktorom bude viditeľný pre ostatné zariadenia Bluetooth."</string>
    <string name="bluetooth_ask_discovery_no_name" product="tablet" msgid="3266007454914144057">"Aplikácia chce na <xliff:g id="TIMEOUT">%1$d</xliff:g> s prepnúť tablet do režimu, v ktorom bude viditeľný pre ostatné zariadenia Bluetooth."</string>
    <string name="bluetooth_ask_discovery_no_name" product="default" msgid="7989444746980501116">"Aplikácia chce na <xliff:g id="TIMEOUT">%1$d</xliff:g> s prepnúť telefón do režimu, v ktorom bude viditeľný pre ostatné zariadenia Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="6482084870735107773">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce prepnúť tablet do režimu, v ktorom bude viditeľný pre ostatné zariadenia Bluetooth. Môžete to neskôr zmeniť v nastaveniach Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="2352494279465502950">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce prepnúť telefón do režimu, v ktorom bude viditeľný pre ostatné zariadenia Bluetooth. Môžete to neskôr zmeniť v nastaveniach Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet" msgid="2732992604509910896">"Aplikácia chce tablet prepnúť do režimu, v ktorom bude viditeľný pre ostatné zariadenia Bluetooth. Môžete to neskôr zmeniť v nastaveniach Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="default" msgid="356982103612920264">"Aplikácia chce telefón prepnúť do režimu, v ktorom bude viditeľný pre ostatné zariadenia Bluetooth. Môžete to neskôr zmeniť v nastaveniach Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="6103655179509599427">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce na <xliff:g id="TIMEOUT">%2$d</xliff:g> s zapnúť Bluetooth a prepnúť tablet do viditeľného režimu."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="934276632311449337">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce na <xliff:g id="TIMEOUT">%2$d</xliff:g> s zapnúť Bluetooth a prepnúť telefón do viditeľného režimu."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="tablet" msgid="1284048348024444485">"Aplikácia chce na <xliff:g id="TIMEOUT">%1$d</xliff:g> s zapnúť Bluetooth a prepnúť tablet do viditeľného režimu."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="default" msgid="2661614145022629454">"Aplikácia chce na <xliff:g id="TIMEOUT">%1$d</xliff:g> s zapnúť Bluetooth a prepnúť telefón do viditeľného režimu."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="8588317955400593623">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnúť Bluetooth a prepnúť tablet do režimu, v ktorom bude viditeľný pre ostatné zariadenia. Môžete to neskôr zmeniť v nastaveniach Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="4047444317445386579">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnúť Bluetooth a prepnúť telefón do režimu, v ktorom bude viditeľný pre ostatné zariadenia. Môžete to neskôr zmeniť v nastaveniach Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="tablet" msgid="4922952478824372605">"Aplikácia chce zapnúť Bluetooth a prepnúť tablet do režimu, v ktorom bude viditeľný pre ostatné zariadenia. Môžete to neskôr zmeniť v nastaveniach Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="default" msgid="1381582950049639439">"Aplikácia chce zapnúť Bluetooth a prepnúť telefón do režimu, v ktorom bude viditeľný pre ostatné zariadenia. Môžete to neskôr zmeniť v nastaveniach Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Bluetooth sa zapína…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Bluetooth sa vypína…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Žiadosť o pripojenie zariadenia Bluetooth"</string>
    <string name="bluetooth_connection_notif_message" msgid="6087344980352898209">"K zariadeniu <xliff:g id="DEVICE_NAME">%1$s</xliff:g> sa pripojíte klepnutím."</string>
    <string name="bluetooth_connection_dialog_text" msgid="2537152772549874391">"Chcete sa pripojiť k zariadeniu „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“?"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Žiadosť o prístup k telefónnemu zoznamu"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="7153531868579789993">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> chce pristupovať k vašim kontaktom a histórii hovorov. Chcete zariadeniu <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> udeliť prístup?"</string>
    <string name="bluetooth_remember_choice" msgid="173821849670438110">"Nabudúce sa nepýtať"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2080511174185036562">"Nabudúce sa nepýtať"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Žiadosť o prístup ku správam"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="2647611490952377156">"Zariadenie %1$s chce získať prístup k vašim správam. Chcete zariadeniu %2$s tento prístup umožniť?"</string>
    <string name="bluetooth_sap_request" msgid="473439406287008397">"Žiadosť o prístup k SIM karte"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="2849083276356078655">"Zariadenie <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> chce pristupovať k vašej SIM karte. Udelenie prístupu k SIM karte zakáže na vašom zariadení dátové pripojenie po dobu jeho trvania. Udeliť prístup zariadeniu <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g>"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Viditeľné pre ostatné zariadenia ako <xliff:g id="DEVICE_NAME">^1</xliff:g>"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Ak sa chcete pripojiť k ostatným zariadeniam, zapnite Bluetooth."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Vaše zariadenia"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Párovanie nového zariadenia"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3506962706611366830">"Povoľte tabletu komunikovať so zariadeniami Bluetooth nablízku"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2192027516577675587">"Povoľte zariadeniu komunikovať so zariadeniami Bluetooth nablízku"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="768958961865499804">"Povoľte telefónu komunikovať so zariadeniami Bluetooth nablízku"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Zakázať hardvérové zníženie záťaže Bluetooth (A2DP)"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title" msgid="8610420176339657720">"Reštartovať?"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message" msgid="8333029144800835996">"Ak chcete zmeniť nastavenie, musíte reštartovať zariadenie."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="3488695418187553566">"Reštartovať"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="4930826928585464191">"Zrušiť"</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Mediálne zariadenia"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Zariadenia na telefonovanie"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Iné zariadenia"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Uložené zariadenia"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Zapne sa Bluetooth s cieľom párovania"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Nastavenia pripojenia"</string>
    <string name="connected_device_previously_connected_title" msgid="605808252622814415">"V minulosti pripojené zariadenia"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Predtým pripojené zariadenia"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Rozhranie Bluetooth je zapnuté"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Zobraziť všetky"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Dátum a čas"</string>
    <string name="choose_timezone" msgid="1450780665958642147">"Zvoľte časové pásmo"</string>
    <!-- no translation found for intent_sender_data_label (1733806423295725392) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="3202857258557610646">"Odoslať <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="257853357827275530">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="519934560779343541">"Spustiť <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="5087385727740280207">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="36614006839665458">"Účet:"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy server"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Vymazať"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Port proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Nepoužívať proxy server pre"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Obnoviť predvolené nastavenia"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Hotovo"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Názov hostiteľa proxy servera"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Upozornenie"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Zadaný názov hostiteľa nie je platný."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Zoznam vylúčení, ktorý ste vytvorili, má nesprávny formát. Zadajte zoznam vylúčených domén a jednotlivé názvy oddeľte čiarkami."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Musíte vyplniť pole port."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Ak je pole hostiteľ prázdne, musí byť prázdne aj pole port."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Zadaný port nie je platný."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Prehliadač používa proxy server protokolu HTTP, ale ostatné aplikácie ho používať nemusia."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"Webová adresa PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Testovať dostupnosť domény (www.google.com) IPv4:"</string>
    <string name="radio_info_ping_hostname_v6" msgid="8327436534663560713">"Testovať dostupnosť domény (www.google.com) IPv6:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Test klienta HTTP:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Spustiť testovanie dostupnosti (ping)"</string>
    <string name="sdcard_changes_instructions" msgid="2331969501845866957">"Zmena sa prejaví pri ďalšom pripojení kábla USB."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="129059989000252994">"Povoliť veľkokapacitné pamäťové zariadenie USB"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="5298511430610207103">"Celková kapacita (bajty):"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="6189761476582690998">"Úložisko USB nie je pripojené."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="6601962586941623203">"Žiadna SD karta."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="7721283102767669004">"Pamäť k dispozícii (bajty):"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="4878190674458263222">"Úložisko USB sa používa ako veľkokapacitné pamäťové zariadenie."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="8850227049504860012">"SD karta sa používa ako veľkokapacitné pamäťové zariadenie."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="1053258530368541571">"Úložisko USB môžete odobrať."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="5813940671700138561">"Teraz môžete SD kartu bezpečne odobrať."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="209564009449909311">"Ukl. priestor USB odstr. počas prevádzky."</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="6817342973919819392">"SD karta bola odstránená počas prevádzky."</string>
    <string name="sdcard_settings_used_bytes_label" msgid="5646588579332741943">"Obsadená pamäť (bajty):"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="8037280964384235345">"Hľad. médií v ukl. priestore USB..."</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="3297316465982471437">"Vyhľadávanie mediálnych súborov na SD karte..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3444648373391629840">"Úložisko USB je pripojené len na čítanie."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4338796260718910164">"SD karta bola pripojená iba na čítanie."</string>
    <string name="skip_label" msgid="6380034601349015895">"Preskočiť"</string>
    <string name="next_label" msgid="1248293387735652187">"Ďalej"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Jazyky"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Odstrániť"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Pridať jazyk"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="2845515796732609837">
      <item quantity="few">Odstrániť vybraté jazyky?</item>
      <item quantity="many">Odstrániť vybraté jazyky?</item>
      <item quantity="other">Odstrániť vybraté jazyky?</item>
      <item quantity="one">Odstrániť vybratý jazyk?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Text sa zobrazí v inom jazyku."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Nie je možné odstrániť všetky jazyky"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Ponechajte aspoň jeden preferovaný jazyk"</string>
    <string name="locale_not_translated" msgid="5079729745235316146">"Nemusí byť k dispozícii v niektorých aplikáciách"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Presunúť nahor"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Presunúť nadol"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Presunúť na začiatok"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Presunúť na koniec"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Odstrániť jazyk"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Zvoliť aktivitu"</string>
    <string name="display_label" msgid="3056320781191343221">"Obrazovka"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="1850505156136467106">"Ukladací priestor USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="8715502912796241588">"SD karta"</string>
    <string name="proxy_settings_label" msgid="6300573815025557843">"Nastavenia servera proxy"</string>
    <string name="cancel" msgid="5780102414089664898">"Zrušiť"</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Zabudnúť"</string>
    <string name="save" msgid="3125033126936493822">"Uložiť"</string>
    <string name="done" msgid="7497982645646431310">"Hotovo"</string>
    <string name="apply" msgid="7834684883190163536">"Použiť"</string>
    <string name="share" msgid="8502235338607613795">"Zdieľať"</string>
    <string name="add" msgid="8335206931421683426">"Pridať"</string>
    <string name="settings_label" msgid="943294133671632976">"Nastavenia"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Nastavenia"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Odkaz na nastavenia"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Režim v lietadle"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Bezdrôtové pripojenia a siete"</string>
    <string name="radio_controls_summary" msgid="9028430178697624501">"Spravovať Wi‑Fi, Bluetooth, režim v lietadle, mobilné siete a siete VPN"</string>
    <string name="cellular_data_summary" msgid="6551434804367912367">"Povoliť využitie dát cez mobilnú sieť"</string>
    <string name="allow_data_usage_title" msgid="2645963379925196671">"Povoliť využ. dát pri roamingu"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Pripájať sa k dátovým službám pri roamingu"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Pripájať sa k dátovým službám pri roamingu"</string>
    <string name="roaming_reenable_message" msgid="5150423860521673540">"Dátové pripojenie bolo prerušené, pretože ste opustili domovskú sieť a máte vypnutý dátový roaming."</string>
    <string name="roaming_turn_it_on_button" msgid="6999283810847157816">"Zapnúť"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Môžu sa účtovať poplatky za roaming."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="5629953315019604726">"Keď povolíte dátový roaming, môžu sa zaň účtovať poplatky.\n\nToto nastavenie platí pre všetkých používateľov tohto tabletu."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="3693719745119874126">"Keď povolíte dátový roaming, môžu sa zaň účtovať poplatky.\n\nToto nastavenie platí pre všetkých používateľov tohto telefónu."</string>
    <string name="roaming_reenable_title" msgid="770824950144026180">"Povoliť dátový roaming?"</string>
    <string name="networks" msgid="5184501333492775095">"Výber operátora"</string>
    <string name="sum_carrier_select" msgid="1669911795517995916">"Zvoliť sieťového operátora"</string>
    <string name="date_and_time_settings_title" msgid="2305454529709812364">"Dátum a čas"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="1841717199409629742">"Nastaviť dátum a čas"</string>
    <string name="date_and_time_settings_summary" msgid="334967758944498010">"Nastaviť dátum, čas, časové pásmo a formáty"</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Nastaviť čas automaticky"</string>
    <string name="zone_auto_title" msgid="3993580453604839924">"Nastaviť časové pásmo automaticky"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Používať miestny predvolený formát"</string>
    <string name="date_time_24hour_title" msgid="1445056824481243600">"24-hodinový formát"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Používať 24-hodinový formát"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Čas"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Formát času"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Časové pásmo"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Časové pásmo"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Dátum"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Vyhľadať oblasť"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Oblasť"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Vybrať časový posun"</string>
    <string name="zone_change_to_from_dst" msgid="686451769985774294">"<xliff:g id="TIME_TYPE">%1$s</xliff:g> sa začína <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</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" msgid="7004693956837388129">"Používa <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Čas <xliff:g id="DST_TIME_TYPE">%2$s</xliff:g> sa začína <xliff:g id="TRANSITION_DATE">%3$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Používa <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Nepoužíva letný čas."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Letný čas"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Štandardný čas"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Vybrať podľa oblasti"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Vybrať podľa čas. posunu UTC"</string>
    <string name="date_picker_title" msgid="646573308567782578">"Dátum"</string>
    <string name="time_picker_title" msgid="1784236407401743393">"Čas"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Uzamknúť po uplynutí časového limitu obrazovky"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po uplynutí časového limitu"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Okamžite po uplynutí časového limitu, ak odomknutie nie je udržiavané funkciou <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po uplynutí časového limitu, ak odomknutie nie je udržiavané funkciou <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="197365342192696406">"Zobrazovať vlastníka na uzamknutej obrazovke"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Pridať text na uzamk. obraz."</string>
    <string name="security_enable_widgets_title" msgid="676199714313423099">"Aktiv. miniaplikácie"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="5191637768484254146">"Zakázané správcom"</string>
    <string name="lockdown_settings_title" msgid="8988970335658365075">"Zobraziť možnosti uzamknutia"</string>
    <string name="lockdown_settings_summary" msgid="7422522013953398806">"Zobrazenie vypínača, ktorý vypína Smart Lock, biometrické odomykanie a upozornenia na uzamknutej obrazovke"</string>
    <string name="trust_lost_locks_screen_title" msgid="4231232144565291276">"Uzamknutie obrazovky v prípade straty dôveryhodnosti"</string>
    <string name="trust_lost_locks_screen_summary" msgid="718374221849537361">"Po aktivácii umožňuje zariadeniu uzamknúť sa, keď posledný agent dôvery stratí dôveryhodnosť"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Žiadne"</string>
    <string name="owner_info_settings_status" msgid="7488764871758677862">"<xliff:g id="COUNT_0">%1$d</xliff:g> / <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Napr. Petrov Android"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="5734739022887933365">"Zobraziť inform. o profile na uzamknutej obrazovke"</string>
    <string name="Accounts_settings_title" msgid="8434263183710375412">"Účty"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Poloha"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Používať polohu"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Vypnuté"</string>
    <plurals name="location_settings_summary_location_on" formatted="false" msgid="1019959038518185676">
      <item quantity="few">Zapnuté – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikácie majú prístup k polohe</item>
      <item quantity="many">On - <xliff:g id="COUNT_1">%1$d</xliff:g> apps have access to location</item>
      <item quantity="other">Zapnuté – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikácií má prístup k polohe</item>
      <item quantity="one">Zapnuté – <xliff:g id="COUNT_0">%1$d</xliff:g> aplikácia má prístup k polohe</item>
    </plurals>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Načítava sa…"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Účty"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Zabezpečenie"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Šifrovanie a poverenia"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="5298195959570992363">"Telefón zašifrovaný"</string>
    <string name="decryption_settings_summary" product="default" msgid="1742645256103613503">"Telefón nie je šifrovaný"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="3776741531205406800">"Zariadenie je šifrované"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="1864963068216544631">"Zariadenie nie je šifrované"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Uzamknutá obrazovka"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Čo zobrazovať"</string>
    <string name="security_settings_summary" msgid="1627059516127354233">"Moja poloha, odomknutie obrazovky, zámok SIM, zámok úložiska poverení"</string>
    <string name="cdma_security_settings_summary" msgid="2455517905101186330">"Nastavenie funkcie Moje poloha, odomknutie obrazovky a zamknutie úložiska poverení"</string>
    <string name="security_passwords_title" msgid="4154420930973818581">"Ochrana súkromia"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Nie je k dispozícii"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Stav zabezpečenia"</string>
    <string name="security_dashboard_summary_face" msgid="4198949293847206382">"Zámka obrazovky, odomknutie tvárou"</string>
    <string name="security_dashboard_summary" msgid="8750183806533140464">"Zámka obrazovky, odtlačok prsta"</string>
    <string name="security_dashboard_summary_no_fingerprint" msgid="1044589595710115123">"Zámka obrazovky"</string>
    <string name="multi_biometric_enroll_title" msgid="3007607723604088374">"Bezpečné odomykanie telefónu tvárou a odtlačkom prsta"</string>
    <string name="multi_biometric_enroll_subtitle" msgid="8357072842904027301">"Môžete sa aj prihlasovať v aplikáciách a potvrdzovať platby"</string>
    <string name="multi_biometric_enroll_setup_with" msgid="421375792889910150">"Nastaviť odomykanie pomocou:"</string>
    <string name="multi_biometric_enroll_face_unlock_title" msgid="7627564065626355692">"Odomknutie tvárou"</string>
    <string name="multi_biometric_enroll_face_unlock_description" msgid="7626442550602926682">"Zjednodušte si odomykanie telefónu"</string>
    <string name="multi_biometric_enroll_fingerprint_unlock_title" msgid="3839935495273854171">"Odtlačok prsta"</string>
    <string name="multi_biometric_enroll_fingerprint_unlock_description" msgid="116938134430420778">"Šetrite čas odomknutím telefónu vo vrecku"</string>
    <string name="multi_biometric_enroll_skip" msgid="7301215196571580858">"Preskočiť"</string>
    <string name="multi_biometric_enroll_next" msgid="6220680618102151619">"Ďalej"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Pridaná tvár"</string>
    <string name="security_settings_face_preference_summary_none" msgid="3758209126322559995">"Nastaviť odomknutie tvárou"</string>
    <string name="security_settings_face_preference_title" msgid="821557938243856757">"Odomknutie tvárou"</string>
    <string name="security_settings_face_profile_preference_title" msgid="4618796080378248740">"Odomknutie tvárou pre prácu"</string>
    <string name="security_settings_face_enroll_education_title" msgid="8662585502032112675">"Ako nastaviť odomknutie tvárou"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="4632402390714441918">"Nastavenie odomknutia tvárou"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Overenie totožnosti pomocou tváre"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Začať"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="4681495507974718824">"Ak je zjednodušené odomknutie tvárou vypnuté, niektoré kroky nastavenia nemusia v čítačke TalkBack fungovať správne."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Späť"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Pokračovať v nastavení"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Použiť nastavenie dostupnosti"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_expanded" msgid="6763509014732769185"></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">"Zrušiť"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Nie, vďaka"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="1822303197642630076">"Súhlasím"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Viac"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Odomykanie pomocou tváre"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Overenie totožnosti pomocou tváre"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="3015751486939484934">"Používajte tvár na odomykanie telefónu, schvaľovanie nákupov a prihlasovanie sa do aplikácií."</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Odomykajte telefón a schvaľujte nákupy tvárou.\n\nUpozornenie: Toto zariadenie nemôžete odomykať tvárou. Ďalšie informácie vám poskytne správca organizácie."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Používajte tvár na odomykanie telefónu, schvaľovanie nákupov a prihlasovanie sa do aplikácií"</string>
    <string name="security_settings_face_enroll_introduction_footer_part_0" msgid="908831787971630413"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_1" msgid="4438129587730915782"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_2" msgid="6099785970191751036"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_3" msgid="8708726599723727710"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Umiestnite svoju tvár do kruhu"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Preskočiť"</string>
    <string name="face_add_max" msgid="4578405795494514876">"Maximálny počet tvárí, ktoré je možné pridať: <xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Pridali ste maximálny počet tvárí"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Nie je možné pridať ďalšie tváre"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Registrácia nebola dokončená"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Časový limit registrácie tváre vypršal. Skúste to znova."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Registrácia tváre nefungovala."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Všetko sa podarilo nastaviť."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Hotovo"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="9080635904939148410">"Zlepšite výkonnosť odomknutia tvárou"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="2318506792574194633">"Znova nastavte odomknutie tvárou"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="8907917317111783249">"Znova nastavte odomknutie tvárou"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Zlepšite zabezpečenie a výkonnosť"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="7124713074067550039">"Nastavte odomknutie tvárou"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="950213874209080175">"Odstráňte aktuálne údaje o tvári a znova nastavte odomknutie tvárou.\n\nÚdaje o tvári využívané odomknutím tvárou budú natrvalo a bezpečne odstránené. Po ich odstránení budete na odomykanie telefónu, prihlasovanie do aplikácií a potvrdzovanie platieb potrebovať PIN, vzor alebo heslo."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="2374998717426341095">"Používať odomknutie tvárou na:"</string>
    <string name="security_settings_face_settings_use_face_unlock_phone" msgid="5209963876503148501">"Odomykanie telefónu"</string>
    <string name="security_settings_face_settings_use_face_for_apps" msgid="8813038341122613020">"Prihlasovanie do aplikácií a platby"</string>
    <string name="security_settings_face_settings_require_category" msgid="3906382658164073665">"Požiadavky na odomknutie tvárou"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Vyžadovať otvorené oči"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Ak chcete odomknúť telefón, musíte mať otvorené oči"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Vždy vyžadovať potvrdenie"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="6454776517804994007">"Pri používaní odomknutia tvárou v aplikáciách požadovať potvrdenie"</string>
    <string name="security_settings_face_settings_remove_face_data" msgid="6491161841504747384">"Odstrániť údaje o tvári"</string>
    <string name="security_settings_face_settings_enroll" msgid="4656842124181309056">"Nastaviť odomknutie tvárou"</string>
    <string name="security_settings_face_settings_top_intro" msgid="4199311264578653665">"Odomykajte svoje zariadenie, prihlasujte sa do aplikácií a potvrdzujte platby pomocou odomknutia tvárou."</string>
    <string name="security_settings_face_settings_footer" msgid="4378074697208244539">"Dôležité upozornenie:\nTelefón môžete náhodne odomknúť pohľadom, aj keď ste to nechceli urobiť.\n\nMôže ho odomknúť aj niekto iný, keď telefón namieri na vašu tvár.\n\nMôže ho odomknúť aj osoba, ktorá sa na vás veľmi podobá, napríklad vaše jednovaječné dvojča."</string>
    <string name="security_settings_face_settings_footer_attention_not_supported" msgid="5051230351151761265">"Dôležité upozornenie:\nTelefón môžete náhodne odomknúť pohľadom, aj keď ste to nechceli urobiť.\n\nMôže ho odomknúť aj niekto iný, keď telefón namieri na vašu tvár, a to dokonca aj vtedy, keď budete mať zatvorené oči.\n\nMôže ho odomknúť aj osoba, ktorá sa na vás veľmi podobá, napríklad vaše jednovaječné dvojča."</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2596803378375165362">"Chcete odstrániť údaje o tvári?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="3458998128212675289">"Údaje o tvári používané na odomknutie tvárou budú natrvalo a bezpečne odstránené. Po ich odstránení budete na odomykanie telefónu, prihlasovanie do aplikácií a potvrdzovanie platieb potrebovať svoj kód PIN, vzor alebo heslo."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="9197485417007952865">"Odomykajte telefón tvárou"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Odtlačok prsta"</string>
    <string name="fingerprint_manage_category_title" msgid="1249349505688268850">"Správa odtlačkov"</string>
    <string name="fingerprint_usage_category_title" msgid="8757959085075024856">"Použiť odtlačok na"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Pridať odtlačok prsta"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5451094461919440992">"zámka obrazovky"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="988602245530967106">
      <item quantity="few">Nastavené <xliff:g id="COUNT_1">%1$d</xliff:g> odtlačky prstov</item>
      <item quantity="many"><xliff:g id="COUNT_1">%1$d</xliff:g> fingerprints set up</item>
      <item quantity="other">Nastavených <xliff:g id="COUNT_1">%1$d</xliff:g> odtlačkov prstov</item>
      <item quantity="one">Nastavený <xliff:g id="COUNT_0">%1$d</xliff:g> odtlačok prsta</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1044059475710838504"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="521797365974277693">"Odomknutie odtlačkom prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Používanie odtlačku prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="1467469714658873533">"Ak chcete odomknúť telefón, autorizovať nákupy alebo sa prihlásiť do aplikácií, stačí sa dotknúť senzora odtlačkov prstov. Dávajte pozor, čie odtlačky pridáte. Tieto operácie bude môcť vykonávať každý pridaný odtlačok."</string>
    <string name="security_settings_fingerprint_enroll_introduction_bottom_message" msgid="6527850754691662946">"Odtlačok prsta môže byť menej bezpečný ako silný vzor alebo PIN"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Odomykajte svoj telefón a schvaľujte nákupy pomocou odtlačku prsta.\n\nUpozornenie: Toto zariadenie nemôžete odomykať pomocou odtlačku prsta. Ďalšie informácie vám poskytne správca organizácie."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="5979556434735281585">"Odomykajte svoj telefón a schvaľujte nákupy pomocou odtlačku prsta.\n\nUpozornenie: Odtlačok prsta môže byť menej bezpečný ako silný vzor alebo kód PIN."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Zrušiť"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Nie, vďaka"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="5683573189775460816">"Pokračovať"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup" msgid="370010932190960403">"Preskočiť"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup" msgid="7155412679784724630">"Ďalej"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Preskočiť odtlačok prsta?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Nastavenie odtlačku prsta trvá približne minútu. Ak tento krok preskočíte, môžete si odtlačok prsta pridať neskôr v Nastaveniach."</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Preskočiť zámku obrazovky?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1570832293693405757">"Funkcie ochrany zariadenia sa nezapnú. V prípade straty, krádeže alebo obnovenia nebudete môcť cudzím osobám zabrániť v používaní tohto tabletu."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="4618501606519351904">"Funkcie ochrany zariadenia sa nezapnú. V prípade straty, krádeže alebo obnovenia nebudete môcť cudzím osobám zabrániť v používaní tohto zariadenia."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="2412426429887900241">"Funkcie ochrany zariadenia sa nezapnú. V prípade straty, krádeže alebo obnovenia nebudete môcť cudzím osobám zabrániť v používaní tohto telefónu."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="7119039592587429936">"Funkcie ochrany zariadenia sa nezapnú. V prípade straty alebo krádeže nebudete môcť cudzím osobám zabrániť v používaní tohto tabletu."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="3365990364131398523">"Funkcie ochrany zariadenia sa nezapnú. V prípade straty alebo krádeže nebudete môcť cudzím osobám zabrániť v používaní tohto zariadenia."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="4908278819257287536">"Funkcie ochrany zariadenia sa nezapnú. V prípade straty alebo krádeže nebudete môcť cudzím osobám zabrániť v používaní tohto telefónu."</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Preskočiť"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Späť"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Preskočiť"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Zrušiť"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Dotknite sa senzora"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Nachádza sa na zadnej strane telefónu. Použite ukazovák."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="1181700918690345832">"Je na obrazovke. Hľadajte odtlačok prsta so žiariacim kruhom."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustrácia zariadenia a umiestnenia senzora odtlačku prsta"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Názov"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Odstrániť"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Dotknite sa senzora"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Priložte prst k senzoru a zdvihnite ho, keď zacítite vibráciu"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Zdvihnite a opäť priložte"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Zdvíhajte prst, aby ste pridali všetky odlišné časti odtlačku prsta"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Odtlačok prsta bol pridaný"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="8220458039597261933">"Keď uvidíte túto ikonu, môžete na identifikáciu alebo schválenie nákupov použiť odtlačok prsta"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Neskôr"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Preskočiť nastavenie odtlačkov prstov?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Vybrali ste, že chcete používať odtlačok prsta ako jeden zo spôsobov odomknutia telefónu. Ak tento krok preskočíte, budete musieť odtlačok prsta nastaviť neskôr. Trvá to približne minútu."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="tablet" msgid="6901147203720764421">"Ochráňte svoj tablet pomocou možnosti zámky obrazovky, aby ho v prípade krádeže alebo straty nemohol nikto použiť. Možnosť zámky obrazovky potrebujete aj na nastavenie odtlačku prsta. Klepnite na Zrušiť, potom nastavte PIN, vzor alebo heslo."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="device" msgid="1286244133923093528">"Ochráňte svoje zariadenie pomocou možnosti zámky obrazovky, aby ho v prípade krádeže alebo straty nemohol nikto použiť. Možnosť zámky obrazovky potrebujete aj na nastavenie odtlačku prsta. Klepnite na Zrušiť, potom nastavte PIN, vzor alebo heslo."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="default" msgid="4810191157587317521">"Ochráňte svoj telefón pomocou možnosti zámky obrazovky, aby ho v prípade krádeže alebo straty nemohol nikto použiť. Možnosť zámky obrazovky potrebujete aj na nastavenie odtlačku prsta. Klepnite na Zrušiť, potom nastavte PIN, vzor alebo heslo."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="tablet" msgid="7387535629289108475">"Keď zabezpečíte svoj tablet pomocou možnosti zámky obrazovky, v prípade krádeže alebo straty ho nebude môcť nikto použiť. Možnosť zámky obrazovky potrebujete aj na nastavenie odomknutia tvárou. Ak chcete prejsť späť, klepnite na Zrušiť."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="device" msgid="4995287019957131123">"Keď zabezpečíte svoje zariadenie pomocou možnosti zámky obrazovky, v prípade krádeže alebo straty ho nebude môcť nikto použiť. Možnosť zámky obrazovky potrebujete aj na nastavenie odomknutia tvárou. Ak chcete prejsť späť, klepnite na Zrušiť."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="default" msgid="7086796722966738156">"Keď zabezpečíte svoj telefón pomocou možnosti zámky obrazovky, v prípade krádeže alebo straty ho nebude môcť nikto použiť. Možnosť zámky obrazovky potrebujete aj na nastavenie odomknutia tvárou. Ak chcete prejsť späť, klepnite na Zrušiť."</string>
    <string name="biometrics_lock_screen_setup_skip_dialog_text" product="tablet" msgid="3943278149639587227">"Keď zabezpečíte svoj tablet pomocou zámky obrazovky, v prípade krádeže alebo straty ho nebude môcť nikto použiť. Zámka obrazovky sa vyžaduje aj pri nastavení biometrie. Ak chcete prejsť späť, klepnite na Zrušiť."</string>
    <string name="biometrics_lock_screen_setup_skip_dialog_text" product="device" msgid="5424064454068220988">"Keď zabezpečíte svoje zariadenie pomocou zámky obrazovky, v prípade krádeže alebo straty ho nebude môcť nikto použiť. Zámka obrazovky sa vyžaduje aj pri nastavení biometrie. Ak chcete prejsť späť, klepnite na Zrušiť."</string>
    <string name="biometrics_lock_screen_setup_skip_dialog_text" product="default" msgid="5668256546179188638">"Keď zabezpečíte svoj telefón pomocou zámky obrazovky, v prípade krádeže alebo straty ho nebude môcť nikto použiť. Zámka obrazovky sa vyžaduje aj pri nastavení biometrie. Ak chcete prejsť späť, klepnite na Zrušiť."</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Chcete preskočiť nastavenie kódu PIN?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Chcete preskočiť nastavenie hesla?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Chcete preskočiť nastavenie vzoru?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Nastaviť zámku obrazovky"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Hotovo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Ojoj, to nie je senzor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Dotknite sa senzora na zadnej strane telefónu. Použite ukazovák."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="132085362209418770">"Registrácia nebola dokončená"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="5479647886550695766">"Časový limit registrácie odtlačku prsta vypršal. Skúste to znova."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="6068935528640241271">"Registrácia odtlačku prsta nefungovala. Skúste to znova alebo použite iný prst."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Pridať ďalší"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Ďalej"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="7875826823637114097">"Okrem odomknutia svojho telefónu môžete pomocou odtlačku prsta schvaľovať nákupy a prístup aplikácií. "<annotation id="url">"Ďalšie informácie"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="4260983700868889294">" Možnosť zámky obrazovky je zakázaná. Ďalšie informácie vám poskytne správca vašej organizácie. "<annotation id="admin_details">"Ďalšie podrobnosti"</annotation>\n\n"Naďalej môžete pomocou odtlačku prsta schvaľovať nákupy a prístup do aplikácií. "<annotation id="url">"Ďalšie informácie"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Nadvihnite prst, potom sa opäť dotknite senzora"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Môžete pridať ďalšie odtlačky (max. <xliff:g id="COUNT">%d</xliff:g>)"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Pridali ste maximálny počet odtlačkov prstov"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nie je možné pridať ďalšie odtlačky prstov"</string>
    <string name="fingerprint_last_delete_title" msgid="4081475675646514726">"Odstrániť všetky odtlačky prstov?"</string>
    <string name="fingerprint_delete_title" msgid="1469865327307917858">"Odstránenie odtlačku prsta <xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>"</string>
    <string name="fingerprint_delete_message" msgid="1454995433333496541">"Chcete tento odtlačok prsta odstrániť?"</string>
    <string name="fingerprint_last_delete_message" msgid="93311579320049852">"Nebudete môcť odomykať telefón, schvaľovať nákupy ani sa prihlasovať do aplikácií odtlačkom prstu."</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="3460246522493987163">"Nebudete môcť odomykať pracovný profil, schvaľovať nákupy ani sa prihlasovať do pracovných aplikácií odtlačkom prstu."</string>
    <string name="fingerprint_last_delete_confirm" msgid="3294910995598819259">"Áno, odstrániť"</string>
    <string name="crypt_keeper_settings_title" msgid="4938812137822100044">"Šifrovanie"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="7484150746479958376">"Šifrovať tablet"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="8302873664348463041">"Šifrovať telefón"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="3866488451639592071">"Šifrované"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="4103951371711323192">"Svoje účty, nastavenia, stiahnuté aplikácie a ich dáta, médiá a ďalšie súbory môžete zašifrovať. Ak tablet zašifrujete a nastavili ste zámku obrazovky (bezpečnostný vzor, číselný kód PIN alebo heslo), bude potrebné ho pri každom zapnutí dešifrovať odomknutím obrazovky. Jediným ďalším spôsobom dešifrovania je obnovenie výrobných nastavení, ktorým vymažete všetky svoje dáta.\n\nŠifrovanie trvá hodinu alebo dlhšie. Šifrovanie je potrebné začať s plne nabitou batériou a počas šifrovania je potrebné nechať tablet pripojený k zdroju napájania. Ak šifrovanie prerušíte, prídete o niektoré alebo všetky svoje dáta."</string>
    <string name="crypt_keeper_desc" product="default" msgid="6180866043921135548">"Svoje účty, nastavenia, stiahnuté aplikácie a ich dáta, médiá a ďalšie súbory môžete zašifrovať. Ak telefón zašifrujete a nastavili ste zámku obrazovky (bezpečnostný vzor, číselný kód PIN alebo heslo), bude potrebné ho pri každom zapnutí dešifrovať odomknutím obrazovky. Jediným ďalším spôsobom dešifrovania je obnovenie výrobných nastavení, ktorým vymažete všetky svoje dáta.\n\nŠifrovanie trvá hodinu alebo dlhšie. Šifrovanie je potrebné začať s plne nabitou batériou a počas šifrovania je potrebné nechať telefón pripojený k zdroju napájania. Ak šifrovanie prerušíte, prídete o niektoré alebo všetky svoje dáta."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="5551608011810921471">"Šifrovať tablet"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="6370330929679426136">"Šifrovať telefón"</string>
    <string name="crypt_keeper_low_charge_text" msgid="4920087247177024521">"Nabite batériu a skúste to znova."</string>
    <string name="crypt_keeper_unplugged_text" msgid="2709721134148651329">"Zapojte nabíjačku a skúste to znova."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="1847280235529858357">"Chýba heslo alebo kód PIN na odomknutie obrazovky"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="7210616262954236042">"Pred spustením šifrovania musíte nastaviť kód PIN alebo heslo zámky obrazovky."</string>
    <string name="crypt_keeper_confirm_title" msgid="8600000209722452230">"Šifrovať?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="3270587498436152259">"Operácia šifrovania je nevratná a ak ju prerušíte, prídete o dáta. Šifrovanie môže trvať viac ako hodinu. Tablet sa počas tejto doby niekoľkokrát reštartuje."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="3040428543349852419">"Operácia šifrovania je nevratná a ak ju prerušíte, prídete o dáta. Šifrovanie môže trvať viac ako hodinu. Telefón sa počas tejto doby niekoľkokrát reštartuje."</string>
    <string name="crypt_keeper_setup_title" msgid="3339725741305796680">"Šifrovanie"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="4417016995091289019">"Čakajte na dokončenie procesu šifrovania tabletu. Dokončené: <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="7902355422499500352">"Čakajte na dokončenie šifrovania telefónu. Dokončené: <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="8348188415839917821">"Počkajte na dokončenie šifrovania tabletu. Zostávajúci čas: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="8556105766597855198">"Počkajte na dokončenie šifrovania telefónu. Zostávajúci čas: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="3832496715430327682">"Ak chcete odomknúť svoj tablet, vypnite ho a potom ho zapnite."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="5070346039522135361">"Ak chcete odomknúť svoj telefón, vypnite ho a potom ho zapnite."</string>
    <string name="crypt_keeper_warn_wipe" msgid="8104921337301750394">"Upozornenie: Po viac ako <xliff:g id="COUNT">^1</xliff:g> neúspešných pokusoch o odomknutie bude vaše zariadenie vymazané!"</string>
    <string name="crypt_keeper_enter_password" msgid="1274917431075529732">"Zadajte svoje heslo"</string>
    <string name="crypt_keeper_failed_title" msgid="8173654570682244149">"Šifrovanie bolo neúspešné"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="5977961188966570342">"Šifrovanie bolo prerušené a nedá sa dokončiť. Výsledkom je, že údaje vo vašom tablete už nie sú k dispozícii. \n\nAk chcete ďalej používať svoj tablet, musíte obnoviť jeho výrobné nastavenia. Po ich obnovení budete mať počas nastavovania tabletu príležitosť obnoviť všetky údaje, ktoré sa zálohovali do vášho účtu Google."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="1028716993071131029">"Šifrovanie bolo prerušené a nedá sa dokončiť. Výsledkom je, že údaje vo vašom telefóne už nie sú k dispozícii. \n\nAk chcete ďalej používať svoj telefón, musíte obnoviť jeho výrobné nastavenia. Po ich obnovení budete mať počas nastavovania telefónu príležitosť obnoviť všetky údaje, ktoré boli zálohované vo vašom účte Google."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="5920153462176846037">"Dešifrovanie sa nepodarilo"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="4420666705959562753">"Zadané heslo je správne, avšak údaje sú poškodené. \n\nAk chcete ďalej používať svoj tablet, musíte obnoviť jeho výrobné nastavenia. Po ich obnovení budete mať počas nastavovania tabletu príležitosť obnoviť všetky údaje, ktoré boli zálohované vo vašom účte Google."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="3200498792238652367">"Zadané heslo je správne, avšak údaje sú poškodené. \n\nAk chcete ďalej používať svoj telefón, musíte obnoviť jeho výrobné nastavenia. Po ich obnovení budete mať počas nastavovania telefónu príležitosť obnoviť všetky údaje, ktoré boli zálohované vo vašom účte Google."</string>
    <string name="crypt_keeper_switch_input_method" msgid="7712732134989470573">"Prepnúť metódu vstupu"</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Zabezpečenie telefónu"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="3213718550422761562">"Nastavenie zámky obrazovky na ochranu tabletu"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="8479766049078378225">"Nastavenie zámky obrazovky na ochranu zariadenia"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="2443273582716671033">"Nastavenie zámky obrazovky na ochranu telefónu"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Odomknutie vyžaduje pridanie odtlačku prsta"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="1040265358906410746"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="1040265358906410746"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="1040265358906410746"></string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Zámka obrazovky"</string>
    <string name="lock_settings_picker_title_profile" msgid="8377696902400733227">"Výber pracovnej zámky"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="1276283007274778191">"Chráňte svoj tablet"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="3585905639045649905">"Chráňte svoje zariadenie"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="2758197863515864300">"Chráňte svoje telefón"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Nastavte si dodatočnú zámku obrazovky a získajte lepšie zabezpečenie"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="4870877800737248926">"Aktivujte funkcie ochrany zariadenia a zabráňte tak ostatným v používaní tohto tabletu bez vášho povolenia. Vyberte zámku obrazovky, ktorú chcete používať."</string>
    <string name="setup_lock_settings_picker_message" product="device" msgid="8961855222808442301">"Aktivujte funkcie ochrany zariadenia a zabráňte tak ostatným v používaní tohto zariadenia bez vášho povolenia. Vyberte zámku obrazovky, ktorú chcete používať."</string>
    <string name="setup_lock_settings_picker_message" product="default" msgid="8867435145945818970">"Aktivujte funkcie ochrany zariadenia a zabráňte tak ostatným v používaní tohto telefónu bez vášho povolenia. Vyberte zámku obrazovky, ktorú chcete používať."</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Zvoľte spôsob aktivovania dodatočnej zámky obrazovky"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Možnosti zámky obrazovky"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Možnosti zámky obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Zámka obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5799070517574360310">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / okamžite po spánku"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_after_timeout" msgid="4572132216801894216">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / <xliff:g id="TIMEOUT_STRING">%2$s</xliff:g> po spánku"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Zámka pracovného profilu"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="4746783679112447948">"Zmeniť uzamknutie obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="6023813780512501969">"Zmeniť alebo zakázať bezpečnostný vzor, kód PIN alebo heslo"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="1699993191343299179">"Vyberte spôsob uzamknutia obrazovky"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Žiadne"</string>
    <string name="unlock_set_unlock_off_summary" msgid="4578319976164001322"></string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Potiahnutie"</string>
    <string name="unlock_set_unlock_none_summary" msgid="641298008390890152">"Bez zabezpečenia"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Vzor"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="4482018884090552709">"Stredné zabezpečenie"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="1961863114590024945">"Stredné až vysoké zabezpečenie"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Heslo"</string>
    <string name="unlock_set_unlock_password_summary" msgid="7647435233968707432">"Vysoké zabezpečenie"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Teraz nie"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Aktuálna zámka obrazovky"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4492334416059646032">"Odtlačok prsta + bezpečnostný vzor"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="4724451168139460493">"Odtlačok prsta + kód PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="5614333047430835971">"Odtlačok prsta + heslo"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Pokračovať bez odtlačku prsta"</string>
    <string name="fingerprint_unlock_title" msgid="4978686534505944042">"Telefón môžete odomknúť odtlačkom prsta. Táto možnosť vyžaduje z bezpečnostných dôvodov dodatočnú zámku obrazovky."</string>
    <string name="face_unlock_set_unlock_pattern" msgid="5991691559532427891">"Odomknutie tvárou a vzor"</string>
    <string name="face_unlock_set_unlock_pin" msgid="8990569318587034610">"Odomknutie tvárou a PIN"</string>
    <string name="face_unlock_set_unlock_password" msgid="8612535943511761549">"Odomknutie tvárou a heslo"</string>
    <string name="face_unlock_skip_face" msgid="7117201898540606846">"Pokračovať bez odomknutia tvárou"</string>
    <string name="face_unlock_title" msgid="7344830351598247267">"Telefón môžete odomknúť pomocou tváre. Táto možnosť vyžaduje z bezpečnostných dôvodov dodatočnú zámku obrazovky."</string>
    <string name="biometrics_unlock_set_unlock_pattern" msgid="8871485472202659">"Biometria a vzor"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="1729940978662427512">"Biometria a PIN"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="5368133215008755916">"Biometria a heslo"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="8260715582785687329">"Pokračovať bez biometrie"</string>
    <string name="biometrics_unlock_title" msgid="7769374223959937435">"Telefón môžete odomknúť pomocou biometrie. Táto možnosť vyžaduje z bezpečnostných dôvodov dodatočnú zámku obrazovky."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="4022867760387966129">"Zakázané správcom, pravidlom šifrovania alebo úložiskom poverení"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Žiadna"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Potiahnutie"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Vzor"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Heslo"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="5974580769186206478">"Po nastavení zámky obrazovky si môžete nastaviť aj svoj odtlačok prsta v časti Nastavenia &gt; Zabezpečenie."</string>
    <string name="unlock_disable_lock_title" msgid="2564279819907932759">"Vypnúť zámku obrazovky"</string>
    <string name="unlock_disable_frp_warning_title" msgid="1520689401825045809">"Odstrániť ochranu zariadenia?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Odstrániť ochranu profilu?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="669384600341275312">"Funkcie ochrany zariadenia nebudú bez vášho vzoru fungovať."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="8160948976853039106">"Funkcie ochrany zariadenia nebudú fungovať bez vášho vzoru.<xliff:g id="EMPTY_LINE">

</xliff:g>Z tohto zariadenia sa tiež odstránia vaše uložené odtlačky prstov a nebudete môcť pomocou nich ďalej odomykať svoj telefón, schvaľovať nákupy ani sa prihlasovať do aplikácií."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="3732073290049930632">"Funkcie ochrany zariadenia nebudú fungovať bez vášho kódu PIN."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="2018020861756931097">"Funkcie ochrany zariadenia nebudú fungovať bez vášho kódu PIN.<xliff:g id="EMPTY_LINE">

</xliff:g>Z tohto zariadenia sa tiež odstránia vaše uložené odtlačky prstov a nebudete môcť pomocou nich ďalej odomykať svoj telefón, schvaľovať nákupy ani sa prihlasovať do aplikácií."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="2130004168084396797">"Funkcie ochrany zariadenia nebudú fungovať bez vášho hesla."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8455564842615579472">"Funkcie ochrany zariadenia nebudú fungovať bez vášho hesla.<xliff:g id="EMPTY_LINE">

</xliff:g>Z tohto zariadenia sa tiež odstránia vaše uložené odtlačky prstov a nebudete môcť pomocou nich ďalej odomykať svoj telefón, schvaľovať nákupy ani sa prihlasovať do aplikácií."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Funkcie ochrany zariadenia nebudú fungovať bez vašej zámky obrazovky."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="4985095359625056279">"Funkcie ochrany zariadenia nebudú fungovať bez vašej zámky obrazovky.<xliff:g id="EMPTY_LINE">

</xliff:g>Z tohto zariadenia sa tiež odstránia vaše uložené odtlačky prstov a nebudete môcť pomocou nich ďalej odomykať svoj telefón, schvaľovať nákupy ani sa prihlasovať do aplikácií."</string>
    <string name="unlock_disable_frp_warning_content_pattern_profile" msgid="6850770024037691891">"Funkcie ochrany zariadenia nebudú fungovať bez vášho bezpečnostného vzoru."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile" msgid="313998125412427527">"Funkcie ochrany profilu nebudú fungovať bez vášho bezpečnostného vzoru.<xliff:g id="EMPTY_LINE">

</xliff:g>Z tohto profilu sa tiež odstránia vaše uložené odtlačky prstov a nebudete môcť pomocou nich ďalej odomykať svoj profil, schvaľovať nákupy ani sa prihlasovať do aplikácií."</string>
    <string name="unlock_disable_frp_warning_content_pin_profile" msgid="6328378875803145738">"Funkcie ochrany zariadenia nebudú fungovať bez vášho kódu PIN."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile" msgid="6844729803535310058">"Funkcie ochrany profilu nebudú fungovať bez vášho kódu PIN.<xliff:g id="EMPTY_LINE">

</xliff:g>Z tohto profilu sa tiež odstránia vaše uložené odtlačky prstov a nebudete môcť pomocou nich ďalej odomykať svoj profil, schvaľovať nákupy ani sa prihlasovať do aplikácií."</string>
    <string name="unlock_disable_frp_warning_content_password_profile" msgid="6922335143823758149">"Funkcie na ochranu zariadenia nebudú fungovať bez vášho hesla."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile" msgid="5724824564583660260">"Funkcie ochrany profilu nebudú fungovať bez vášho hesla.<xliff:g id="EMPTY_LINE">

</xliff:g>Z tohto profilu sa tiež odstránia vaše uložené odtlačky prstov a nebudete môcť pomocou nich ďalej odomykať svoj profil, schvaľovať nákupy ani sa prihlasovať do aplikácií."</string>
    <string name="unlock_disable_frp_warning_content_unknown_profile" msgid="6886183964362015704">"Funkcie ochrany zariadenia nebudú fungovať bez vašej zámky obrazovky."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile" msgid="3754195701700959477">"Funkcie ochrany profilu nebudú fungovať bez vašej zámky obrazovky.<xliff:g id="EMPTY_LINE">

</xliff:g>Z tohto profilu sa tiež odstránia vaše uložené odtlačky prstov a nebudete môcť pomocou nich ďalej odomykať svoj profil, schvaľovať nákupy ani sa prihlasovať do aplikácií."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="621607297961726537">"Áno, odstrániť"</string>
    <string name="unlock_change_lock_pattern_title" msgid="8234523589333929193">"Zmena bezpečnostného vzoru"</string>
    <string name="unlock_change_lock_pin_title" msgid="2324077520816477479">"Zmena bezpečnostného kódu PIN"</string>
    <string name="unlock_change_lock_password_title" msgid="873517913969091074">"Zmeniť bezpečnostné heslo"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> odporúča silný kód PIN alebo heslo, bez ktorého nemusí fungovať podľa očakávaní"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> odporúča nový kód PIN alebo heslo, bez ktorého nemusí fungovať podľa očakávaní"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> odporúča nový vzor, PIN alebo heslo, bez ktorého nemusí fungovať podľa očakávaní"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> odporúča nová zámku obrazovky"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Skúste to znova. <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g>. z <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g> pokusov."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Vaše dáta budú odstránené"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Ak pri ďalšom pokuse zadáte nesprávny vzor, dáta tohto zariadenia budú odstránené"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Ak pri ďalšom pokuse zadáte nesprávny kód PIN, dáta tohto zariadenia budú odstránené"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Ak pri ďalšom pokuse zadáte nesprávne heslo, dáta tohto zariadenia budú odstránené"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Ak pri ďalšom pokuse zadáte nesprávny vzor, tento používateľ bude odstránený"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Ak pri ďalšom pokuse zadáte nesprávny kód PIN, tento používateľ bude odstránený"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Ak pri ďalšom pokuse zadáte nesprávne heslo, tento používateľ bude odstránený"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Ak pri ďalšom pokuse zadáte nesprávny vzor, váš pracovný profil a jeho dáta budú odstránené"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Ak pri ďalšom pokuse zadáte nesprávny PIN, váš pracovný profil a jeho dáta budú odstránené"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Ak pri ďalšom pokuse zadáte nesprávne heslo, váš pracovný profil a jeho dáta budú odstránené"</string>
    <string name="lock_failed_attempts_now_wiping_device" msgid="2813744895409014471">"Príliš veľa chybných pokusov. Dáta tohto zariadenia budú odstránené."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="3958755474620948727">"Príliš veľa chybných pokusov. Tento používateľ bude odstránený."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="3171880997211568208">"Príliš veľa chybných pokusov. Tento pracovný profil a jeho dáta budú odstránené."</string>
    <string name="lock_failed_attempts_now_wiping_dialog_dismiss" msgid="170155081899679669">"Zavrieť"</string>
    <plurals name="lockpassword_password_too_short" formatted="false" msgid="2192234965414232157">
      <item quantity="few">Musí mať aspoň <xliff:g id="COUNT_1">%d</xliff:g> znaky</item>
      <item quantity="many">Must be at least <xliff:g id="COUNT_1">%d</xliff:g> characters</item>
      <item quantity="other">Musí mať aspoň <xliff:g id="COUNT_1">%d</xliff:g> znakov</item>
      <item quantity="one">Musí mať aspoň <xliff:g id="COUNT_0">%d</xliff:g> znak</item>
    </plurals>
    <plurals name="lockpassword_pin_too_short" formatted="false" msgid="6817086810898414162">
      <item quantity="few">PIN musí mať aspoň <xliff:g id="COUNT_1">%d</xliff:g> číslice</item>
      <item quantity="many">PIN must be at least <xliff:g id="COUNT_1">%d</xliff:g> digits</item>
      <item quantity="other">PIN musí mať aspoň <xliff:g id="COUNT_1">%d</xliff:g> číslic</item>
      <item quantity="one">PIN musí mať aspoň ako <xliff:g id="COUNT_0">%d</xliff:g> číslicu</item>
    </plurals>
    <string name="lockpassword_continue_label" msgid="2507983991979547816">"Pokračovať"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="8118091957172967677">
      <item quantity="few">Musí mať menej ako <xliff:g id="NUMBER_1">%d</xliff:g> znaky</item>
      <item quantity="many">Must be fewer than <xliff:g id="NUMBER_1">%d</xliff:g> characters</item>
      <item quantity="other">Musí mať menej ako <xliff:g id="NUMBER_1">%d</xliff:g> znakov</item>
      <item quantity="one">Musí mať menej ako <xliff:g id="NUMBER_0">%d</xliff:g> znak</item>
    </plurals>
    <plurals name="lockpassword_pin_too_long" formatted="false" msgid="8706992338720310765">
      <item quantity="few">Musí mať menej ako <xliff:g id="NUMBER_1">%d</xliff:g> číslice</item>
      <item quantity="many">Must be fewer than <xliff:g id="NUMBER_1">%d</xliff:g> digits</item>
      <item quantity="other">Musí mať menej ako <xliff:g id="NUMBER_1">%d</xliff:g> číslic</item>
      <item quantity="one">Musí mať menej ako <xliff:g id="NUMBER_0">%d</xliff:g> číslicu</item>
    </plurals>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Správca zariadenia neumožňuje používať nedávny kód PIN"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Musí obsahovať iba platné znaky"</string>
    <string name="lockpassword_password_requires_alpha" msgid="721084100957669018">"Musí obsahovať aspoň jedno písmeno"</string>
    <string name="lockpassword_password_requires_digit" msgid="312518567592683795">"Musí obsahovať aspoň jednu číslicu"</string>
    <string name="lockpassword_password_requires_symbol" msgid="6178512486154701321">"Musí obsahovať aspoň jeden symbol"</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="2385916409676839024">
      <item quantity="few">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> písmená</item>
      <item quantity="many">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> písmena</item>
      <item quantity="other">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> písmen</item>
      <item quantity="one">Musí obsahovať aspoň 1 písmeno</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="2057467885488612701">
      <item quantity="few">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> malé písmená</item>
      <item quantity="many">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> malého písmena</item>
      <item quantity="other">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> malých písmen</item>
      <item quantity="one">Musí obsahovať aspoň 1 malé písmeno</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="4541266279643052025">
      <item quantity="few">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> veľké písmená</item>
      <item quantity="many">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> veľkého písmena</item>
      <item quantity="other">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> veľkých písmen</item>
      <item quantity="one">Musí obsahovať aspoň 1 veľké písmeno</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="70617964591376248">
      <item quantity="few">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> čísla</item>
      <item quantity="many">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> čísla</item>
      <item quantity="other">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> čísel</item>
      <item quantity="one">Musí obsahovať aspoň 1 číslo</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="7981236881269921943">
      <item quantity="few">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> špeciálne symboly</item>
      <item quantity="many">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> špeciálneho symbolu</item>
      <item quantity="other">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> špeciálnych symbolov</item>
      <item quantity="one">Musí obsahovať aspoň 1 špeciálny symbol</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="1567877061888948467">
      <item quantity="few">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> znaky, ktoré nie sú písmená</item>
      <item quantity="many">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> znaku, ktorý nie je písmeno</item>
      <item quantity="other">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> znakov, ktoré nie sú písmená</item>
      <item quantity="one">Musí obsahovať aspoň 1 znak, ktorý nie je písmeno</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonnumerical" formatted="false" msgid="5056743974888384475">
      <item quantity="few">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> znaky, ktoré nie sú číslice</item>
      <item quantity="many">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> znakov, ktoré nie sú číslice</item>
      <item quantity="other">Musí obsahovať aspoň <xliff:g id="COUNT">%d</xliff:g> znakov, ktoré nie sú číslice</item>
      <item quantity="one">Musí obsahovať aspoň jeden znak, ktorý nie je číslica</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Správca zariadenia neumožňuje používať nedávne heslo"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Vzostupná, zostupná alebo opakovaná sekvencia čísiel nie je povolená"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Potvrdiť"</string>
    <string name="lockpassword_cancel_label" msgid="6711112212489992112">"Zrušiť"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Vymazať"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Zámka obrazovky už bola zmenená. Skúste to znova s novou zámkou obrazovky."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Zrušiť"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Ďalej"</string>
    <string name="lock_setup" msgid="4622999020926280737">"Nastavenie je dokončené."</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Aplikácie na správu zariadenia"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Žiadne aktívne aplikácie"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="2528735319390151989">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> aktívne aplikácie</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> aktívnej aplikácie</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aktívnych aplikácií</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> aktívna aplikácia</item>
    </plurals>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Agenty dôvery"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Pred použitím treba nastaviť zámku obrazovky"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Žiadne"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="5438047398376802735">
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aktívne agenty dôvery</item>
      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> aktívneho agenta dôvery</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aktívnych agentov dôvery</item>
      <item quantity="one">1 aktívny agent dôvery</item>
    </plurals>
    <string name="bluetooth_quick_toggle_title" msgid="5955341060378240781">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5257744297562880017">"Zapnúť Bluetooth"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="6805458703566046784">"Správa pripojenia, nastavenie názvu zariadenia a viditeľnosti"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Spárovať so zariadením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Párovací kód Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Zadajte párovací kód a potom stlačte tlačidlo Return alebo Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN obsahuje písmená či symboly"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Obvykle 0000 alebo 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Musí obsahovať 16 číslic"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Tento kód PIN bude možno treba zadať aj na druhom zariadení."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Tento prístupový kľúč možno bude potrebné zadať aj v druhom zariadení."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="327192310468680072">"Párovanie so zariadením:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Uistite sa, že zobrazuje tento prístupový kľúč:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1068123527866596779">"Zo zariadenia:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Párovať s týmto zariadením?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="8672803845151786521">"Ak chcete svoje zariadenie spárovať so zariadením <xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>, zadajte na ňom kód <xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g> a stlačte kláves Enter."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Povoliť prístup ku kontaktom a histórii hovorov"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Nepodarilo sa pripojiť k zariadeniu <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="3460316252463771851">"Vyhľadať zariadenia"</string>
    <string name="bluetooth_search_for_devices" msgid="6516902340975407648">"Obnoviť"</string>
    <string name="bluetooth_searching_for_devices" msgid="6541984133657573124">"Hľadá sa…"</string>
    <string name="bluetooth_preference_device_settings" msgid="1688662188157019998">"Nastavenie zariadenia"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="1090131276572055841">"Spárované zariadenie"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="4337953030661626289">"Internetové pripojenie"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="8247634441638919886">"Klávesnica"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="8194423860397844579">"Kontakty a história hovorov"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="6106058683134173178">"Spárovať s týmto zariadením?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="5472835166206721325">"Zdieľať telefónny zoznam?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="7516277926581535299">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> chce pristúpiť k vašim kontaktom a histórii hovorov."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="1545098121090892788">"Zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> žiada o spárovanie s rozhraním Bluetooth. Po pripojení bude mať prístup ku kontaktom a histórii hovorov."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Dostupné zariadenia"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="1331122763066030155">"Nie sú k dispozícii žiadne zariadenia"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Pripojiť"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Odpojiť"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Párovať a pripojiť"</string>
    <string name="bluetooth_device_context_unpair" msgid="7525735305244087162">"Zrušiť párovanie"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="2001359431289794561">"Odpojiť a zrušiť párovanie"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="934657460643490773">"Možnosti…"</string>
    <string name="bluetooth_menu_advanced" msgid="7633682234855216066">"Rozšírené"</string>
    <string name="bluetooth_advanced_titlebar" msgid="5369701494951467257">"Rozšírené nastavenia Bluetooth"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Keď je zapnuté pripojenie Bluetooth, zariadenie môže komunikovať s ostatnými zariadeniami s funkciou Bluetooth v okolí."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="4069064120315578780">"Keď je zapnuté pripojenie Bluetooth, zariadenie môže komunikovať s ostatnými zariadeniami Bluetooth v okolí.\n\nNa vylepšenie funkcií zariadenia môžu aplikácie a služby kedykoľvek vyhľadávať zariadenia v okolí, a to aj vtedy, keď je rozhranie Bluetooth vypnuté. Vďaka tomu je napríklad možné vylepšiť funkcie a služby podmienené polohou. Môžete to zmeniť v "<annotation id="link">"nastaveniach vyhľadávania"</annotation>"."</string>
    <string name="ble_scan_notify_text" msgid="1358879010396045164">"Systémové aplikácie a služby môžu i tak rozpoznávať zariadenia Bluetooth, aby zlepšili presnosť určovania polohy. Toto správanie môžete zmeniť v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastaveniach vyhľadávania<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_failed" msgid="7892663424429584925">"Nepodarilo sa pripojiť. Skúste to znova."</string>
    <string name="device_details_title" msgid="1155622417516195481">"O zariadení"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Adresa Bluetooth zariadenia: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Zabudnúť zariadenie?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="4730377171981539265">"Váš telefón už nebude spárovaný so zariadením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="tablet" msgid="3428463407231980054">"Váš tablet už nebude spárovaný so zariadením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="device" msgid="5117397433721336918">"Vaše zariadenie už nebude spárované so zariadením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_untethered_unpair_dialog_body" msgid="1938465582242297905">"Zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> už nebude spárované so žiadnym zariadením prepojeným s týmto účtom"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Zabudnúť zariadenie"</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="1323072239637864488">"Pripojiť k…"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="339103864166293612">"Zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojené od zvukovej jednotky média."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="7857706184371154920">"Zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojené od zvukovej jednotky handsfree."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="4794752406024916925">"Profil <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojený od vstupného zariadenia."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="283176886159444413">"Prístup na Internet prostredníctvom zariadenia <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude ukončený."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="733193449967330892">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> prestane zdieľať internetové pripojenie tohto tabletu."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="7852265676243153982">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> prestane zdieľať internetové pripojenie tohto telefónu."</string>
    <string name="bluetooth_device_advanced_title" msgid="1181664272013729515">"Spárované zariadenia Bluetooth"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="8302236592496988747">"Pripojiť"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="271856759516576615">"Umožňuje pripojenie zariadenia s rozhraním Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="7892879890208207223">"Použitie"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="4798081898389041132">"Premenovať"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="7604726126703453984">"Povoliť prichádzajúce prenosy súborov"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="7851033200857999275">"Pripojené k zariadeniu s prístupom k internetu"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="5563892893331988809">"Zdieľa miestne internetové pripojenie so zariadením"</string>
    <string name="bluetooth_dock_settings" msgid="1709536202189755022">"Nastavenia doku"</string>
    <string name="bluetooth_dock_settings_title" msgid="4872789068019972847">"Použiť zvuk doku"</string>
    <string name="bluetooth_dock_settings_headset" msgid="5756482379574272554">"Ako reproduktor telefónu"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="434520221656010141">"Pre hudbu a médiá"</string>
    <string name="bluetooth_dock_settings_remember" msgid="6993526033095292609">"Zapamätať nastavenia"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maximálny počet pripojených zvukových zariadení Bluetooth"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Výber maximálneho počtu pripojených zvukových zariadení Bluetooth"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Prenos"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"zrkadlenie"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Povoliť bezdrôtové zobrazenie"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"V okolí sa nenašli žiadne zariadenia."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Prepája sa"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Pripojené"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"Používa sa"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Nie je k dispozícii"</string>
    <string name="wifi_display_details" msgid="2351632307998142920">"Nastavenia obrazovky"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Možnosti bezdrôtového zobrazenia"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Odstrániť"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Hotovo"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Názov"</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_sign_in_button_text" msgid="8483892122845654850">"Prihlásiť sa"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Otvoriť web"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Zostáva <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Platí do <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_tap_to_sign_in" msgid="8658506618807549483">"Klepnite tu a prihláste sa tak do siete"</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">"<xliff:g id="REQUESTER">%s</xliff:g> chce zapnúť Wi‑Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> chce vypnúť Wi‑Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Overovať bajtkód laditeľných aplikácií"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Povoliť nástroju ART overovať bajtkód laditeľných aplikácií"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Zobraziť frekv. obnovenia"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Zobraziť aktuálnu frekvenciu obnovenia obrazovky"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="3622326550467939809">"Výmena dát je možná, keď sa tablet dotýka zariadenia NFC"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="1460871052409162980">"Výmena dát je možná, keď sa telefón dotýka zariadenia NFC"</string>
    <string name="nfc_disclaimer_title" msgid="3696580694485048039">"Zapnutie NFC"</string>
    <string name="nfc_disclaimer_content" msgid="8256675597551036207">"NFC posiela dáta medzi týmto zariadením a ďalšími zariadeniami alebo cieľmi v okolí, ako sú platobné terminály, čítačky prístupových médií a interaktívne reklamy alebo značky."</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Vyžadovať odomknutie zariadenia pre NFC"</string>
    <string name="nfc_secure_toggle_summary" product="default" msgid="4591286109299690373">"Povoliť technológiu NFC na platby a použitie pre verejnú dopravu iba na odomknutej obrazovke"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Pripravené na prenos obsahu aplikácie prostredníctvom NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Vypnuté"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Nedostupné, pretože technológia NFC je vypnutá"</string>
    <string name="android_beam_label" msgid="7168565080321110094">"Android Beam"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Keď je táto funkcia zapnutá a podržíte zariadenia blízko pri sebe, môžete odosielať obsah aplikácií do iného zariadenia s technológiou NFC. Môžete napríklad odosielať webové stránky, videá YouTube, kontakty a ďalší obsah.\n\nStačí priložiť zariadenia k sebe (obyčajne zadnými stranami) a potom klepnúť na obrazovku. Aplikácia určí, aký obsah sa prenesie."</string>
    <string name="wifi_quick_toggle_title" msgid="2737097538432862807">"Wi‑Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="4957267477820468553">"Zapnúť Wi‑Fi"</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi‑Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Používať Wi‑Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Nastavenia Wi‑Fi"</string>
    <string name="wifi_settings_title" msgid="3879649725059512799">"Wi‑Fi"</string>
    <string name="wifi_settings_summary" msgid="784074686763572811">"Umožňuje nastaviť a spravovať prístupové body bezdrôtovej siete"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Vybrať sieť Wi‑Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Prebieha zapínanie siete Wi‑Fi..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Prebieha vypínanie Wi‑Fi..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Chyba"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"V tejto krajine nie je pásmo 5 GHz k dispozícii"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"Režim v lietadle"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Upozorňovať na verejné siete"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Upozorniť na dostupnosť verejnej siete vysokej kvality"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Zapínať Wi‑Fi automaticky"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"V dosahu kvalitných uložených sietí, napríklad vašej domácej siete, sa Wi‑Fi znova zapne"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Nedostupné, pretože funkcia polohy je vypnutá. Zapnúť funkciu "<annotation id="link">"polohy"</annotation>"."</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="1771489741850119751">"Nedostupné, pretože vyhľadávanie sietí Wi‑Fi je vypnuté"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="3615120120960539780">"Ak sa chcete automaticky pripájať, je potrebné vybrať poskytovateľa hodnotenia siete"</string>
    <string name="wifi_poor_network_detection" msgid="8210035875160288422">"Vyhnúť sa nekvalitným pripojeniam"</string>
    <string name="wifi_poor_network_detection_summary" msgid="383834617032605347">"Nepoužívať sieť Wi‑Fi, pokiaľ nemá dostatočne kvalitné internetové pripojenie"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4993203473116721772">"Použiť iba siete s dobrým pripojením k internetu"</string>
    <string name="use_open_wifi_automatically_title" msgid="7193846454986712009">"Pripájať k verejným sieťam"</string>
    <string name="use_open_wifi_automatically_summary" msgid="6663890845558591023">"Automaticky pripájať ku kvalitným verejným sieťam"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="2299284032301667622">"Ak sa chcete automaticky pripájať, je potrebné vybrať poskytovateľa hodnotenia siete"</string>
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled" msgid="1780306481499369913">"Ak sa chcete automaticky pripájať, je potrebné vybrať kompatibilného poskytovateľa hodnotenia siete"</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Inštalácia certifikátov"</string>
    <string name="wifi_scan_notify_text" msgid="2518097467707535013">"Aplikácie a služby môžu kedykoľvek vyhľadávať siete Wi-Fi aj vtedy, keď je pripojenie Wi-Fi vypnuté, aby tak zlepšovali presnosť pri určovaní polohy. Môžete to využiť napríklad na zlepšenie funkcií a služieb podmienených polohou. Môžete to zmeniť v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastaveniach vyhľadávania<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="6189528915806353667">"Ak chcete spresniť určovanie polohy, zapnite vyhľadávanie sietí Wi‑Fi v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastaveniach vyhľadávania<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="8436897497968907701">"Túto správu znova nezobrazovať"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="6285374200292675649">"Wi‑Fi zapnuté aj v režime spánku"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8753852404141070878">"Wi‑Fi aktívne v režime spánku"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="4512566787805720422">"Pri zmene nastavení sa vyskytol problém"</string>
    <string name="wifi_suspend_efficiency_title" msgid="3589291227092825754">"Zlepšiť výkonnosť"</string>
    <string name="wifi_suspend_optimizations" msgid="5840680940416640209">"Optimalizácia Wi‑Fi"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="8204170804523356781">"Minimalizovať spotrebu batérie pri zapnutej sieti Wi‑Fi"</string>
    <string name="wifi_limit_optimizations_summary" msgid="8461087338100462302">"Obmedz. využitie batérie sieťou Wi‑Fi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="681353878530696197">"Prepínať na mobilné dáta, keď sieť Wi‑Fi nebude mať pripojenie k internetu"</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Automaticky prepnúť na mobilné dáta"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Používať mobilné dáta, keď Wi‑Fi nemá prístup k internetu. Za využité dáta vám môžu byť účtované poplatky."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Pridať sieť"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Nastavenia Wi‑Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi sa automaticky znova zapne"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi‑Fi sa nezapína automaticky znova"</string>
    <string name="wifi_access_points" msgid="5846755709207101844">"Siete Wi‑Fi"</string>
    <string name="wifi_menu_more_options" msgid="1236651929987819716">"Ďalšie možnosti"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi‑Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="3498653582115656526">"Vyhľadávanie"</string>
    <string name="wifi_menu_advanced" msgid="1940919392030994019">"Rozšírené"</string>
    <string name="wifi_menu_configure" msgid="352423980467311427">"Konfigurácia"</string>
    <string name="wifi_menu_connect" msgid="7824796427932811078">"Pripojiť k sieti"</string>
    <string name="wifi_menu_remember" msgid="8639523871321603112">"Zapamätať sieť"</string>
    <string name="wifi_menu_forget" msgid="6557142984528657361">"Odstrániť sieť"</string>
    <string name="wifi_menu_modify" msgid="7246143391161038875">"Upraviť sieť"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Ak chcete zobraziť dostupné siete, zapnite Wi‑Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="5043989454000825717">"Vyhľadávajú sa siete Wi‑Fi..."</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Nemáte povolenie na zmenu siete Wi‑Fi."</string>
    <string name="wifi_more" msgid="8742256421693351035">"Ďalšie"</string>
    <string name="wifi_setup_wps" msgid="4303694722593999931">"Automatické nastavenie (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Zapnúť vyhľadávanie sietí Wi‑Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Ak chcete automaticky zapínať Wi-Fi, najskôr musíte zapnúť vyhľadávanie sietí Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Vyhľadávanie sietí Wi-Fi umožňuje aplikáciám a službám kedykoľvek vyhľadávať siete Wi‑Fi, a to aj vtedy, keď je funkcia Wi-Fi vypnutá. Dajú sa tak napríklad zlepšiť funkcie a služby závislé od polohy."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Zapnúť"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Vyhľadávanie sietí Wi‑Fi je zapnuté"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Rozšírené možnosti"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Rozbaľovací zoznam Pokročilé možnosti"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"rozbaliť"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Názov siete"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Zadajte SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Zabezpečenie"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Skrytá sieť"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Ak váš smerovač nevysiela ID určitej siete, ale chcete sa k nej pripojiť v budúcnosti, môžete ju nastaviť ako skrytú.\n\nMôže tým vzniknúť bezpečnostné riziko, pretože váš telefón bude pravidelne vysielať signál, aby sieť našiel.\n\nNastavením danej siete ako skrytej nezmeníte nastavenia smerovača."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Sila signálu"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Stav"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Rýchlosť posielania dát"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Rýchlosť prijímania dát"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Rýchlosť pripojenia"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frekvencia"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"Adresa IP"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Uložené prostredníctvom siete"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Poverenia: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"Metóda EAP"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Druhá fáza overenia"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Certifikát CA"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Stav online certifikátu"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Doména"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Certifikát používateľa"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identita"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonymná identita"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Heslo"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Zobrazovať heslo"</string>
    <string name="wifi_ap_band_config" msgid="1589020070150933055">"Vybrať pásmo pre prístupový bod"</string>
    <string name="wifi_ap_choose_auto" msgid="8944442003151215691">"Automaticky"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Pásmo 2,4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8413248472288180075">"Pásmo 5 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Preferuje sa pásmo 5 GHz"</string>
    <string name="wifi_ap_2G" msgid="4099628221864343015">"2,4 GHz"</string>
    <string name="wifi_ap_5G" msgid="3493942667238551207">"5 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="5221193733812493435">"Vyberte aspoň jedno pásmo pre hotspot Wi-Fi:"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Nastavenia adresy IP"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Ochrana súkromia"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Odber"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Zobrazenie alebo zmena odberu"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Randomizovaná adresa MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Pridanie zariadenia"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Ak chcete pridať zariadenie do siete <xliff:g id="SSID">%1$s</xliff:g>, vycentrujte QR kód nižšie"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Skenovanie QR kódu"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Ak sa chcete pripojiť k sieti <xliff:g id="SSID">%1$s</xliff:g>, vycentrujte QR kód nižšie"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Pripojte sa k sieti Wi‑Fi naskenovaním QR kódu"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Zdieľať Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Ak sa chcete pripojiť k sieti <xliff:g id="SSID">%1$s</xliff:g>, naskenujte tento QR kód iným zariadením"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Ak sa chcete pripojiť k sieti <xliff:g id="SSID">%1$s</xliff:g>, naskenujte tento QR kód"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Skúste to znova. Ak problém pretrváva, kontaktujte výrobcu zariadenia."</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Vyskytol sa problém"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Skontrolujte, či je zariadenie zapojené, nabité a zapnuté"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Skontrolujte, či je zariadenie zapojené, nabité a zapnuté. Ak problém pretrváva, kontaktujte výrobcu zariadenia."</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Toto zariadenie nepodporuje pridanie siete <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Skúste presunúť zariadenie bližšie k prístupovému bodu Wi-Fi alebo smerovaču"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Skontrolujte heslo a skúste to znova"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Kontaktujte výrobcu zariadenia"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Skontrolujte pripojenie a skúste to znova"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Výber siete"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Ak chcete pripojiť svoje zariadenie, vyberte sieť"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Chcete pridať toto zariadenie do siete <xliff:g id="SSID">%1$s</xliff:g>?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi sa zdieľa so zariadením"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Pridať ďalšie zariadenie"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Vybrať inú sieť"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Zariadenie sa nepodarilo pridať"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Našlo sa zariadenie"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"S týmto zariadením sa zdieľa pripojenie Wi‑Fi…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Pripája sa…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Zdieľať hotspot"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Overenie vašej totožnosti"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Heslo siete Wi‑Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Heslo hotspotu: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automaticky pripájať"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Povoľte pripojenie k tejto sieti, keď je v dosahu"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Pridať zariadenie"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Pridajte zariadenie do tejto siete pomocou QR kódu"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR kód nie je platný formát"</string>
    <string name="retry" msgid="7542103800274026915">"Skúsiť znova"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Zdieľať s ostatnými používateľmi zariadenia"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(nezmenené)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Vyberte"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Bolo pridaných viacero certifikátov)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Použiť certifikáty systému"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Neposkytovať"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4673867078988209732">"Neoverovať"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Názov siete je príliš dlhý."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Je potrebné zadať doménu."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Vyžaduje sa certifikát."</string>
    <string name="wifi_wps_available_first_item" msgid="5780501151792036589">"WPS je k dispozícii"</string>
    <string name="wifi_wps_available_second_item" msgid="1717024103303480804">" (WPS je k dispozícii)"</string>
    <string name="wifi_carrier_connect" msgid="4511538300946413213">"Sieť Wi‑Fi operátora"</string>
    <string name="wifi_carrier_content" msgid="2876499905644083615">"Pripojené prostredníctvom operátora <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnúť vyhľadávanie sietí (z dôvodu dosiahnutia vyššej presnosti určovania polohy aj z iných dôvodov) a hľadať siete aj v prípade, že je vypnutý modul Wi‑Fi.\n\nChcete túto možnosť povoliť všetkým aplikáciám, ktoré chcú vyhľadávať siete?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Neznáma aplikácia chce na zlepšenie presnosti určovania polohy a ďalšie účely zapnúť vyhľadávanie sietí, aj keď je vypnutá funkcia Wi‑Fi.\n\nChcete to povoliť všetkým aplikáciám, ktoré chcú vyhľadávať siete?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="93691286302680448">"Ak chcete toto nastavenie vypnúť, prejdite na položku Rozšírené v rozšírenej ponuke."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Povoliť"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Zamietnuť"</string>
    <string name="wifi_hotspot_title" msgid="1918712370697971229">"Chcete sa prihlásiť, aby ste sa mohli pripojiť?"</string>
    <string name="wifi_hotspot_message" msgid="5245614124614833169">"<xliff:g id="APP_NAME">%1$s</xliff:g> vyžaduje, aby ste sa pred pripoj. k sieti prihlásili online"</string>
    <string name="wifi_hotspot_connect" msgid="1916314048788438331">"PRIPOJIŤ"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Táto sieť nemá prístup k internetu. Zachovať pripojenie?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Niektoré aplikácie a služby nemusia fungovať z dôvodu obmedzeného pripojenia. Chcete sieť napriek tomu použiť?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Nabudúce sa na túto sieť nepýtať"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Wi‑Fi nie je pripojené k internetu"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Ak máte slabé pripojenie Wi‑Fi, môžete prepnúť na mobilnú sieť. Za využité dáta vám však môžu byť účtované poplatky."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Prepnúť na mobilné dáta"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Ďalej používať Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Viac už nezobrazovať"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Pripojiť"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Pripojenie Wi‑Fi je zapnuté"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Pripojené k sieti <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Pripája sa k sieti <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Pripája sa…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Nepodarilo sa pripojiť k sieti"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Sieť nie je v dosahu"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Odstrániť"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Upraviť"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Sieť sa nepodarilo odstrániť"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Uložiť"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Nepodarilo sa uložiť sieť"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Zrušiť"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Odstrániť sieť?"</string>
    <string name="wifi_forget_dialog_message" msgid="8419499588321940243">"Všetky heslá pre túto sieť budú odstránené"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="2802436466732147888">
      <item quantity="few">%d siete</item>
      <item quantity="many">%d siete</item>
      <item quantity="other">%d sietí</item>
      <item quantity="one">1 sieť</item>
    </plurals>
    <plurals name="wifi_saved_passpoint_access_points_summary" formatted="false" msgid="5802057518058840450">
      <item quantity="few">%d odbery</item>
      <item quantity="many">%d subscriptions</item>
      <item quantity="other">%d odberov</item>
      <item quantity="one">1 odber</item>
    </plurals>
    <plurals name="wifi_saved_all_access_points_summary" formatted="false" msgid="5125849180309374451">
      <item quantity="few">%d siete a odbery</item>
      <item quantity="many">%d networks &amp; subscriptions</item>
      <item quantity="other">%d sietí a odberov</item>
      <item quantity="one">1 sieť a odber</item>
    </plurals>
    <string name="wifi_advanced_titlebar" msgid="1234150304285575798">"Wi‑Fi, rozšírené"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Adresa MAC zariadenia"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Randomizovaná adresa MAC"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Randomizovaná adresa MAC (naposledy použitá)"</string>
    <string name="wifi_advanced_ip_address_title" msgid="4265355419782184514">"Adresa IP"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Podrobnosti siete"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Maska podsiete"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"Adresy IPv6"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Uložené siete"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Odbery"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Ostatné siete"</string>
    <string name="wifi_advanced_settings_label" msgid="5880605751602184383">"Nastavenia adresy IP"</string>
    <string name="wifi_advanced_not_available" msgid="8701003884367299092">"Rozšírené nastavenia Wi‑Fi nie sú pre tohto používateľa dostupné"</string>
    <string name="wifi_ip_settings_menu_save" msgid="5190481040428567106">"Uložiť"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="1757817733064004598">"Zrušiť"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Zadajte platnú adresu IP."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Zadajte platnú adresu brány."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Zadajte platnú adresu DNS."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Zadajte dĺžku sieťovej predpony v rozsahu 0 až 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"1. systém DNS (pokiaľ nie je prepísaný súkromným)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"2. systém DNS (pokiaľ nie je prepísaný súkromným)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Brána"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Dĺžka sieťovej predpony"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi‑Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="4304362679971797283">"Informácie o zariadení"</string>
    <string name="wifi_p2p_persist_network" msgid="7942929491568227945">"Zapamätať si toto pripojenie"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Vyhľadávanie zariadení"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Hľadá sa…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Premenovať zariadenie"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Partnerské zariadenia"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Zapamätané skupiny"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Nepodarilo sa pripojiť."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Premenovanie zariadenia zlyhalo."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Odpojiť?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Ak sa odpojíte, ukončíte spojenie so zariadením <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Ak sa odpojíte, ukončíte spojenie so zariadením <xliff:g id="PEER_NAME">%1$s</xliff:g> a ďalšími zariadeniami (<xliff:g id="PEER_COUNT">%2$s</xliff:g>)."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Zrušiť pozvánku?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Chcete zrušiť pozvánku na spojenie s klientom <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Odstrániť túto skupinu?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Hotspot Wi‑Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"S inými zariadeniami sa nezdieľa internet ani obsah"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5832429443898690152">"Internetové pripojenie tohto tabletu sa zdieľa cez hotspot"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="default" msgid="5451921191609178326">"Internetové pripojenie tohto telefónu sa zdieľa cez hotspot"</string>
    <string name="wifi_hotspot_on_local_only_subtext" msgid="965051079784031636">"Aplikácia zdieľa obsah. Ak chcete zdieľať internetové pripojenie, vypnite hotspot a potom ho zapnite."</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Nie je nastavené žiadne heslo"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Názov hotspotu"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="2094754115215428892">"Zapína sa hotspot <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>…"</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="6935457127884928249">"Iné zariadenia sa môžu pripojiť k hotspotu <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Heslo hotspotu"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Pásmo prístup. bodu"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="6620216295510397461">"Použite hotspot na vytvorenie siete Wi‑Fi pre ostatné zariadenia. Hotspot poskytuje internet pomocou mobilného dátového pripojenia. Môžu vám byť účtované ďalšie poplatky za mobilné dáta."</string>
    <string name="wifi_hotspot_footer_info_local_only" msgid="3813311942370920903">"Aplikácie tiež môžu vytvoriť hostpot na zdieľanie obsahu so zariadeniami v okolí."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Hotspot automaticky vypínať"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Keď nie sú pripojené žiadne zariadenia"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Prebieha zapínanie hotspotu..."</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Prebieha vypínanie hotspotu..."</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"Sieť <xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktívna"</string>
    <string name="wifi_tether_failed_subtext" msgid="437190628041885500">"Chyba hotspotu siete Wi‑Fi"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7072559431286459122">"Nastaviť hotspot Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="9027072969831022321">"Nastavenie hotspotu Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="1445157424926935178">"Hotspot AndroidAP WPA2 PSK"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Chcete túto sieť uložiť?"</string>
    <string name="wifi_add_app_single_network_summary" product="default" msgid="6881712878537666626">"<xliff:g id="APPNAME">%1$s</xliff:g> chce uložiť sieť do vášho telefónu"</string>
    <string name="wifi_add_app_single_network_summary" product="tablet" msgid="8455616967601552440">"<xliff:g id="APPNAME">%1$s</xliff:g> chce uložiť sieť do vášho tabletu"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Ukladá sa…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Uložené"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Nie je možné uložiť. Skúste to znova."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Chcete siete uložiť?"</string>
    <string name="wifi_add_app_networks_summary" product="default" msgid="2670215712788515167">"<xliff:g id="APPNAME">%1$s</xliff:g> chce uložiť tieto siete do vášho telefónu"</string>
    <string name="wifi_add_app_networks_summary" product="tablet" msgid="2088967184512169910">"<xliff:g id="APPNAME">%1$s</xliff:g> chce uložiť tieto siete do vášho tabletu"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Ukladajú sa siete (<xliff:g id="NUMBER">%d</xliff:g>)…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Siete boli uložené"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Volanie cez Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Rozšírte hovory pomocou volania cez Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Zapnutie volania cez Wi‑Fi na rozšírenie dostupnosti"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Predvoľba volania"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Predvoľba volania"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Predvoľby roamingu"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Predvoľby roamingu"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi‑Fi"</item>
    <item msgid="8622872038388687383">"Mobilné dáta"</item>
    <item msgid="3027927219952052398">"Len Wi‑Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi‑Fi"</item>
    <item msgid="7566603075659706590">"Mobilné dáta"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"V prípade nedostupnosti siete Wi‑Fi použiť mobilnú sieť"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"V prípade nedostupnosti mobilnej siete použiť Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Volanie cez Wi‑Fi. Keď sa Wi‑Fi preruší, hovor sa ukončí."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Ak je zapnuté volanie cez Wi‑Fi, váš telefón môže smerovať volania cez siete Wi‑Fi alebo cez sieť vášho operátora. Závisí to od vašich preferencií a od toho, ktorý signál je silnejší. Pred zapnutím tejto funkcie kontaktujte svojho operátora a informujte sa o poplatkoch a ďalších podrobnostiach.<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="3490633500025717573">"Tiesňová adresa"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Používa sa ako vaša poloha pri tiesňových volaniach cez Wi‑Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Ďalšie informácie"</annotation>" o funkciách súkromného režimu DNS"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Zapnuté"</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="129524064888622179">"Nastavenie spravuje operátor"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktivujte volanie cez Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Zapnite volanie cez Wi-Fi"</string>
    <string name="wifi_calling_not_supported" msgid="3303917737849393175">"Operátor %1$s nepodporuje volanie cez Wi-Fi"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Odpojené od siete <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="carrier" msgid="1755020806290963951">"Operátor"</string>
    <string name="display_settings_title" msgid="626835071804834218">"Obrazovka"</string>
    <string name="sound_settings" msgid="5514582720435174014">"Zvuk"</string>
    <string name="all_volume_title" msgid="6196367642878437513">"Hlasitosti"</string>
    <string name="musicfx_title" msgid="5458574743312283473">"Hudobné efekty"</string>
    <string name="ring_volume_title" msgid="4869034595079914541">"Hlasitosť zvonenenia a upozornení"</string>
    <string name="vibrate_in_silent_title" msgid="5076579100685867363">"Vibrovať v tichom režime"</string>
    <string name="notification_sound_title" msgid="8747567935870133157">"Predvolený zvuk upozornenia"</string>
    <string name="incoming_call_volume_title" msgid="8445408274513654261">"Tón zvonenia"</string>
    <string name="notification_volume_title" msgid="328053763590888609">"Upozornenie"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1798481722572489141">"Použije hlasitosť prichádzajúcich hovorov aj pre upozornenia"</string>
    <string name="home_work_profile_not_supported" msgid="2605589489324241338">"Nepodporuje pracovné profily"</string>
    <string name="notification_sound_dialog_title" msgid="7431891669251806266">"Predvolený zvuk upozornenia"</string>
    <string name="media_volume_title" msgid="5209147840160985178">"Médiá"</string>
    <string name="media_volume_summary" msgid="4671324482655564873">"Umožňuje nastaviť hlasitosť hudby a videí"</string>
    <string name="alarm_volume_title" msgid="706302621191735343">"Budík"</string>
    <string name="dock_settings_summary" msgid="8548721822219932359">"Nastavenia zvuku pre pripojený dok"</string>
    <string name="dtmf_tone_enable_title" msgid="2241337296249130217">"Zvuky pri dotyku číselníku"</string>
    <string name="sound_effects_enable_title" msgid="328569690466233866">"Zvuky klepnutia"</string>
    <string name="lock_sounds_enable_title" msgid="804365014499259673">"Zvuk uzamknutia obrazovky"</string>
    <string name="audio_record_proc_title" msgid="486071779724181619">"Potlačenie hluku"</string>
    <string name="volume_media_description" msgid="2736061076584067204">"Hudba, video, hry a ďalšie médiá"</string>
    <string name="volume_ring_description" msgid="5423168446359881864">"Zvonenie a upozornenia"</string>
    <string name="volume_notification_description" msgid="3241009629930030492">"Upozornenia"</string>
    <string name="volume_alarm_description" msgid="156563371961039376">"Budíky"</string>
    <string name="volume_ring_mute" msgid="1445718401945149622">"Vypnúť zvuk tónu zvonenia a upozornení"</string>
    <string name="volume_media_mute" msgid="1881020121757820746">"Vypnúť zvuk hudby a iných médií"</string>
    <string name="volume_notification_mute" msgid="2612197659377126312">"Vypnúť zvuk upozornení"</string>
    <string name="volume_alarm_mute" msgid="3730895630530980760">"Vypnúť zvuk budíka"</string>
    <string name="dock_settings" msgid="4654404127402812514">"Dok"</string>
    <string name="dock_settings_title" msgid="1276956575555480214">"Nastavenie doku"</string>
    <string name="dock_audio_settings_title" msgid="8294821925086965934">"Zvuk"</string>
    <string name="dock_audio_summary_desk" msgid="4158593887711452737">"Nastavenia pripojeného stolného doku"</string>
    <string name="dock_audio_summary_car" msgid="292911654994476080">"Nastavenia pripojeného doku do auta"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="7758416095500202500">"Tablet nie je vložený do doku"</string>
    <string name="dock_audio_summary_none" product="default" msgid="9056359991181743485">"Telefón nie je vložený do doku"</string>
    <string name="dock_audio_summary_unknown" msgid="5486086330763810318">"Nastavenia pripojeného doku"</string>
    <string name="dock_not_found_title" msgid="4721157149003423417">"Dok nebol nájdený"</string>
    <string name="dock_not_found_text" product="tablet" msgid="9192097687086523411">"Pred nastavením zvuku doku v ňom musí byť vložený tablet."</string>
    <string name="dock_not_found_text" product="default" msgid="2247163115146852069">"Pred nastavením zvuku doku v ňom musí byť vložený telefón."</string>
    <string name="dock_sounds_enable_title" msgid="2974614136344237932">"Zvuk pri vkladaní do doku"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="468592489565539336">"Prehrať zvuk pri vkladaní alebo odstraňovaní tabletu z doku"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8121670617316301768">"Prehrať zvuk pri vkladaní alebo odstraňovaní telefónu z doku"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="7833926726878567889">"Neprehrávať zvuk pri vkladaní alebo odstraňovaní tabletu z doku"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="5560601997128422001">"Neprehrávať zvuk pri vkladaní alebo odstraňovaní telefónu z doku"</string>
    <string name="account_settings" msgid="255404935489127404">"Účty"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Účty pracovných profilov – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Účty osobných profilov"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Pracovný účet – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Osobný účet – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Hľadať"</string>
    <string name="display_settings" msgid="7197750639709493852">"Obrazovka"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Automaticky otáčať obrazovku"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Farby"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Prirodzené"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Zosilnené"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Sýte"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Adaptívna"</string>
    <string name="color_mode_summary_natural" msgid="8298840714001791628">"Používať iba presné farby"</string>
    <string name="color_mode_summary_automatic" msgid="8157885594041700275">"Vyberte si medzi živými a presnými farbami"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="6413384391658481700">"Pri otáčaní tabletu automaticky prepínať orientáciu"</string>
    <string name="accelerometer_summary_on" product="default" msgid="7117139542131700779">"Pri otáčaní telefónu automaticky prepínať orientáciu"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="3747370091309939684">"Pri otáčaní tabletu automaticky prepínať orientáciu"</string>
    <string name="accelerometer_summary_off" product="default" msgid="4451125241783158763">"Pri otáčaní telefónu automaticky prepínať orientáciu"</string>
    <string name="brightness" msgid="6216871641021779698">"Úroveň jasu"</string>
    <string name="brightness_title" msgid="5457874893085305155">"Jas"</string>
    <string name="brightness_summary" msgid="6309641759293018049">"Nastavenia jasu obrazovky"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Adaptácia jasu"</string>
    <string name="auto_brightness_summary" msgid="1737148869232725883">"Jas obrazovky sa prispôsobí okoliu"</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Zapnuté"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Vypnuté"</string>
    <string name="auto_brightness_summary_very_low" msgid="2705445901659224330">"Preferovaný jas je veľmi nízky"</string>
    <string name="auto_brightness_summary_low" msgid="1606100911112851291">"Preferovaný jas je nízky"</string>
    <string name="auto_brightness_summary_default" msgid="9038441148247815684">"Preferovaný jas je predvolený"</string>
    <string name="auto_brightness_summary_high" msgid="2886260311484349010">"Preferovaný jas je vysoký"</string>
    <string name="auto_brightness_summary_very_high" msgid="8294814315426024005">"Preferovaný jas je veľmi vysoký"</string>
    <string name="auto_brightness_off_title" msgid="5156056957376839677">"Vypnutý"</string>
    <string name="auto_brightness_very_low_title" msgid="618973599332847430">"Veľmi nízky"</string>
    <string name="auto_brightness_low_title" msgid="4243763334776382492">"Nízky"</string>
    <string name="auto_brightness_default_title" msgid="1776584786251120907">"Predvolené"</string>
    <string name="auto_brightness_high_title" msgid="6472704542949390468">"Vysoký"</string>
    <string name="auto_brightness_very_high_title" msgid="4935132626750630713">"Veľmi vysoký"</string>
    <string name="auto_brightness_subtitle" msgid="6839449395639517870">"Preferovaná úroveň jasu"</string>
    <string name="auto_brightness_off_summary" msgid="4993150980274474226">"Neupravovať podľa okolitého svetla"</string>
    <string name="auto_brightness_very_high_summary" msgid="2784981315548144255">"Zvýšená spotreba batérie"</string>
    <string name="auto_brightness_disclaimer" msgid="1868395832774087351">"Optimalizovať jas podľa okolitého svetla. Keď je táto funkcia zapnutá, môžete jas stále dočasne upraviť."</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Jas obrazovky sa automaticky prispôsobí prostrediu a aktivitám. Ručným posúvaním posúvača učíte adaptáciu jasu svoje preferované nastavenia."</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Zobrazenie vyváženia bielej"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Plynulý obraz"</string>
    <string name="peak_refresh_rate_summary" msgid="1527087897198455042">"Automaticky zvyšuje frekvenciu obnovenia zo 60 na 90 Hz pre určitý obsah. Zvýši sa spotreba batérie."</string>
    <string name="force_high_refresh_rate_toggle" msgid="5861514655252832828">"Vynútiť frekvenciu obnovenia 90 Hz"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Najvyššia frekvencia obnovenia zlepšujúca dotykovú odozvu a kvalitu animácií. Zvýši sa spotreba batérie."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Vnímavá obrazovka"</string>
    <string name="adaptive_sleep_summary_on" msgid="313187971631243800">"Zapnuté, obrazovka sa nevypne, keď sa na ňu budete pozerať"</string>
    <string name="adaptive_sleep_summary_off" msgid="5272156339202897523">"Vypnuté"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Vyžaduje sa prístup k fotoaparátu"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5107880175176848307">"Klepnutím môžete spravovať povolenia služieb prispôsobenia zariadenia"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Zabráni vypnutiu obrazovky, keď sa na ňu budete pozerať"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Vnímavá obrazovka pomocou predného fotoaparátu zistí, či sa používateľ pozerá na obrazovku. Spúšťa sa v zariadení a snímky sa nikdy neukladajú ani neodosielajú Googlu."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Zapnúť vnímavú obrazovku"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Nechať obrazovku zapnutú, keď ju pozeráte"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Nočný režim"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Nočný režim zafarbí obrazovku do žltohneda. Obrazovka bude pri tlmenom osvetlení menej rušivá aj čitateľnejšia a bude sa vám lepšie zaspávať."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Časový plán"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Nikdy"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Zapnuté vo vybranom čase"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Od západu do východu slnka"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Čas začatia"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Čas ukončenia"</string>
    <string name="night_display_status_title" msgid="9006282950657941820">"Stav"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intenzita"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Nikdy sa automaticky nezapne"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Zapne sa automaticky o <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Zapne sa automaticky pri západe slnka"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Nikdy sa automaticky nevypne"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Vypne sa automaticky o <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Vypne sa automaticky pri východe slnka"</string>
    <string name="night_display_activation_on_manual" msgid="7999294858026069365">"Zapnúť"</string>
    <string name="night_display_activation_off_manual" msgid="4842907786868153218">"Vypnúť"</string>
    <string name="night_display_activation_on_twilight" msgid="3440889451767582067">"Zapnúť do východu slnka"</string>
    <string name="night_display_activation_off_twilight" msgid="2853594955401726956">"Vypnúť do západu slnka"</string>
    <string name="night_display_activation_on_custom" msgid="4951143503599226846">"Zapnúť do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="79965738861100371">"Vypnúť do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Nočný režim nie je zapnutý"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Na určenie časov západu a východu slnka je potrebná poloha zariadenia."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Nastavenia polohy"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Zapnúť"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Vypnúť"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Zapnúť do východu slnka"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Vypnúť do západu slnka"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Tmavý režim"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Plán"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Nikdy"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Od západu do východu slnka"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Zapne sa vo vybranom čase"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Stav"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Nikdy sa automaticky nezapne"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Zapne sa automaticky pri západe slnka"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Zapne sa automaticky o <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Nikdy sa automaticky nevypne"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Vypne sa automaticky pri východe slnka"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Vypne sa automaticky o <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_activation_on_custom" msgid="1889379402860316125">"Zapnúť do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_activation_off_custom" msgid="2192932161592759607">"Vypnúť do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tmavý motív na niektorých obrazovkách používa čierne pozadie a predlžuje tak výdrž batérie. Plány tmavého motívu sa zapnú až po vypnutí obrazovky."</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Časový limit obrazovky"</string>
    <string name="screen_timeout_title" msgid="785134393520893049">"Vypnutie obrazovky"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"<xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> nečinnosti"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Tapeta"</string>
    <string name="style_and_wallpaper_settings_title" msgid="7580575814098427579">"Štýly a tapety"</string>
    <string name="wallpaper_settings_summary_default" msgid="7569803705735001813">"Predvolené"</string>
    <string name="wallpaper_settings_summary_custom" msgid="3174561317688848729">"Vlastná"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Zmeniť tapetu"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Prispôsobte si obrazovku"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Vybrať tapetu"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Prispôsobenie telefónu"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Vyskúšajte rôzne štýly, tapety atď."</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Šetrič obrazovky"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Pri nabíjaní alebo v doku"</string>
    <string name="screensaver_settings_summary_either_short" msgid="2126139984738506920">"V oboch prípadoch"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Pri nabíjaní"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Pri vložení do doku"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nikdy"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Vypnuté"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1166343194760238835">"Ak chcete ovládať, čo sa má stať, keď je telefón v doku alebo v režime spánku, zapnite šetrič obrazovky."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Čas spustenia"</string>
    <string name="screensaver_settings_current" msgid="390472865895976891">"Aktuálny šetrič obrazovky"</string>
    <string name="screensaver_settings_dream_start" msgid="6486360145976995856">"Spustiť"</string>
    <string name="screensaver_settings_button" msgid="6159236558934930238">"Nastavenia"</string>
    <string name="automatic_brightness" msgid="4599827881929079513">"Automatický jas"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Prebudiť zdvihnutím"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Ambientné zobrazenie"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kedy zobrazovať"</string>
    <string name="doze_title" msgid="1523090408230862316">"Prebudiť obraz. na upozornenia"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Keď je obrazovka tmavá, zapne sa v prípade nových upozornení"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Vždy zobrazovať čas a údaje"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Zvýšená spotreba batérie"</string>
    <string name="force_bold_text" msgid="3636373986786504634">"Tučný text"</string>
    <string name="title_font_size" msgid="570613010306330622">"Veľkosť písma"</string>
    <string name="short_summary_font_size" msgid="184712645848458143">"Zväčšite alebo zmenšite text"</string>
    <string name="sim_lock_settings" msgid="4493069398250139205">"Zámka SIM karty"</string>
    <string name="sim_lock_settings_category" msgid="4280307997492851625">"Zámka SIM karty"</string>
    <string name="sim_lock_settings_summary_off" msgid="4570941250786847095">"Vypnuté"</string>
    <string name="sim_lock_settings_summary_on" msgid="1562184566830887925">"Zamknuté"</string>
    <string name="sim_lock_settings_title" msgid="1401619059761012696">"Zámka SIM karty"</string>
    <string name="sim_pin_toggle" msgid="98754920202404425">"Zamykať SIM kartu"</string>
    <string name="sim_lock_on" product="tablet" msgid="5857965768682972363">"Na použitie tabletu vyžadovať PIN"</string>
    <string name="sim_lock_on" product="default" msgid="3303147192981388923">"Na použitie telefónu vyžadovať PIN"</string>
    <string name="sim_lock_off" product="tablet" msgid="7188936582548721225">"Na použitie tabletu vyžadovať PIN"</string>
    <string name="sim_lock_off" product="default" msgid="4634118006847137785">"Na použitie telefónu vyžadovať PIN"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Zmeniť PIN SIM karty"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"Kód PIN SIM karty"</string>
    <string name="sim_enable_sim_lock" msgid="8993991669975548653">"Zamykať SIM kartu"</string>
    <string name="sim_disable_sim_lock" msgid="7656447857474746157">"Odomknúť SIM kartu"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Starý kód PIN SIM karty"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Nový kód PIN SIM karty"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Potvrďte nový kód PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"Kód PIN SIM karty"</string>
    <string name="sim_bad_pin" msgid="5416328363761048221">"Nesprávny kód PIN"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Kódy PIN sa nezhodujú"</string>
    <string name="sim_change_failed" msgid="316723087029061740">"Kód PIN nie je možné zmeniť.\nKód PIN je zrejme nesprávny."</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"Kód PIN SIM karty bol zmenený."</string>
    <string name="sim_lock_failed" msgid="16360418201678317">"Stav zámku SIM karty nie je možné zmeniť.\nZrejme ste zadali nesprávny kód PIN."</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Kód PIN sa nedá deaktivovať."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Kód PIN sa nedá aktivovať."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Zrušiť"</string>
    <string name="sim_multi_sims_title" msgid="4875083890014013296">"Našlo sa viacero SIM kariet"</string>
    <string name="sim_multi_sims_summary" msgid="1711012455679332238">"Vyberte preferovanú SIM kartu na mobilné dáta."</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Používať <xliff:g id="CARRIER">%1$s</xliff:g> na mobilné dáta?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Používate mobilné dáta od operátora <xliff:g id="CARRIER2_0">%2$s</xliff:g>. Ak prepnete na <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> sa už nebude používať na mobilné dáta."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Používať <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="7182406911552216373">"Aktualizovať pref. SIM kartu?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> je jediná SIM karta v zariadení. Chcete ju použiť na mobilné dáta, hovory a správy SMS?"</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Nesprávny kód PIN SIM karty. Teraz musíte kontaktovať svojho operátora, aby vám odomkol zariadenie."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="4054088588731305475">
      <item quantity="few">Nesprávny kód PIN SIM karty. Zostávajú vám <xliff:g id="NUMBER_1">%d</xliff:g> pokusy.</item>
      <item quantity="many">Nesprávny kód PIN SIM karty. Zostáva vám <xliff:g id="NUMBER_1">%d</xliff:g> pokusu.</item>
      <item quantity="other">Nesprávny kód PIN SIM karty. Zostáva vám <xliff:g id="NUMBER_1">%d</xliff:g> pokusov.</item>
      <item quantity="one">Nesprávny kód PIN SIM karty. Zostáva vám <xliff:g id="NUMBER_0">%d</xliff:g> pokus, potom budete musieť kontaktovať svojho operátora, aby vám odomkol zariadenie.</item>
    </plurals>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Nesprávny kód PIN SIM karty. Zostáva vám jeden pokus, inak budete musieť kontaktovať operátora, aby vám odomkol zariadenie."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Operácia kódu PIN SIM karty zlyhala!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Aktualizácie systému"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Verzia systému Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Aktualizácia zabezpečenia Androidu"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_info" msgid="7035211991066637019">"Model a hardvér"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Hardvérová verzia"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID zariadenia"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Verzia základného pásma"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Verzia jadra"</string>
    <string name="build_number" msgid="9009733242117579826">"Číslo zostavy"</string>
    <string name="module_version" msgid="1787518340082046658">"Aktualizácia systému Google Play"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Nie je k dispozícii"</string>
    <string name="device_status_activity_title" msgid="1812666241137263882">"Stav"</string>
    <string name="device_status" msgid="7988547478034984649">"Stav"</string>
    <string name="device_status_summary" product="tablet" msgid="8826216824111648900">"Stav batérie, siete a ďalšie informácie"</string>
    <string name="device_status_summary" product="default" msgid="8132661857066128832">"Telefónne číslo, signál atď."</string>
    <string name="storage_settings" msgid="7472188817781592677">"Úložisko"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Ukladací priestor a vyrovnávacia pamäť"</string>
    <string name="storage_usb_settings" msgid="7058142934214211583">"Úložisko"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Nastavenia úložiska"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3858049818577638926">"Odpojiť ukladací priestor USB a zobraziť dostupný ukladací priestor"</string>
    <string name="storage_settings_summary" product="default" msgid="267557695753980969">"Umožňuje odpojiť SD kartu a zobraziť dostupný ukladací priestor"</string>
    <string name="imei_multi_sim" msgid="71477088017585479">"IMEI (%1$d. slot na SIM kartu)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Zobrazte výberom uloženej siete"</string>
    <string name="status_number" product="tablet" msgid="3597945414666253183">"MDN"</string>
    <string name="status_number" product="default" msgid="8407999629121682207">"Telefónne číslo"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="6582203988975619529">"MDN (%1$d. slot na SIM kartu)"</string>
    <string name="status_number_sim_slot" product="default" msgid="5724823197745786398">"Telefón (%1$d. slot na SIM)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="4239876366511743428">"MDN SIM karty"</string>
    <string name="status_number_sim_status" product="default" msgid="2772745542921910086">"Telefónne číslo SIM karty"</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">"Verzia PRL"</string>
    <string name="meid_multi_sim" msgid="7645394486193991388">"MEID (%1$d. slot na SIM kartu)"</string>
    <string name="scanning_status_text_wifi_on_ble_on" msgid="7644609329607744714">"Vyhľadávanie sietí Wi‑Fi aj zariadení Bluetooth je zapnuté"</string>
    <string name="scanning_status_text_wifi_on_ble_off" msgid="7215007787287418186">"Vyhľadávanie sietí Wi‑Fi je zapnuté, vyhľadávanie zariadení Bluetooth je vypnuté"</string>
    <string name="scanning_status_text_wifi_off_ble_on" msgid="1396882599556304165">"Vyhľadávanie zariadení Bluetooth je zapnuté, vyhľadávanie sietí Wi‑Fi je vypnuté"</string>
    <string name="scanning_status_text_wifi_off_ble_off" msgid="7670694707427030537">"Vyhľadávanie sietí Wi‑Fi aj zariadení Bluetooth je vypnuté"</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">"Typ mobilnej dátovej siete"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Typ mobilnej hlasovej siete"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Informácie o operátorovi"</string>
    <string name="status_data_state" msgid="525196229491743487">"Stav mobilnej siete"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Stav služby"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Sila signálu"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Sieť"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Adresa MAC siete Wi‑Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Adresa MAC siete Wi‑Fi zariadenia"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Adresa Bluetooth"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Sériové číslo"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Doba prevádzky"</string>
    <string name="status_awake_time" msgid="2573925324168081586">"Doba prevádzky"</string>
    <string name="internal_memory" msgid="1869518160077033848">"Interný ukl. priestor"</string>
    <string name="sd_memory" product="nosdcard" msgid="5456718463397723781">"Ukladací priestor USB"</string>
    <string name="sd_memory" product="default" msgid="3098344183202722455">"SD karta"</string>
    <string name="memory_available" msgid="712528795743654737">"K dispozícii"</string>
    <string name="memory_available_read_only" msgid="3201969221573511590">"K dispozícii (len na čítanie)"</string>
    <string name="memory_size" msgid="2710897518522931469">"Celková pamäť"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Prebieha výpočet..."</string>
    <string name="memory_apps_usage" msgid="8818570780540532952">"Aplikácie a dáta aplikácií"</string>
    <string name="memory_media_usage" msgid="5161308657995646963">"Médiá"</string>
    <string name="memory_downloads_usage" msgid="8252462247720191179">"Stiahnuté"</string>
    <string name="memory_dcim_usage" msgid="3568913845973164352">"Obrázky, videá"</string>
    <string name="memory_music_usage" msgid="8100634000114206429">"Zvuk (hudba, podcasty atď.)"</string>
    <string name="memory_media_misc_usage" msgid="7066851245178533269">"Ostatné súbory"</string>
    <string name="memory_media_cache_usage" msgid="780808666853685824">"Dáta vo vyrovnávacej pamäti"</string>
    <string name="sd_eject" product="nosdcard" msgid="6136102589751843304">"Odpojte zdieľaný ukl. priestor"</string>
    <string name="sd_eject" product="default" msgid="8062832622096296251">"Odpojiť SD kartu"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="6859940774161708871">"Odp. interný ukl. priestor USB"</string>
    <string name="sd_eject_summary" product="default" msgid="5151243312587186226">"Kvôli bezpečnému odstráneniu SD karty musíte kartu najprv odpojiť"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="9164545135649775664">"Vložte ukl. priestor USB na pripoj."</string>
    <string name="sd_insert_summary" product="default" msgid="5949168259622002192">"Vložte SD kartu, ktorú chcete pripojiť"</string>
    <string name="sd_mount" product="nosdcard" msgid="8305985249945415150">"Pripoj. ukl. priestor USB"</string>
    <string name="sd_mount" product="default" msgid="5279813999455776169">"Pripojiť SD kartu"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="2190410240845521205"></string>
    <string name="sd_mount_summary" product="default" msgid="2190410240845521205"></string>
    <string name="sd_format" product="nosdcard" msgid="8657427883364711513">"Vymazať ukladací priestor USB"</string>
    <string name="sd_format" product="default" msgid="9085302892248732329">"Vymazať SD kartu"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6179784504937189658">"Vymaže vš. údaje v internom uklad. priestore USB, napr. hudbu alebo fotografie."</string>
    <string name="sd_format_summary" product="default" msgid="60583152211068164">"Vymaže všetky údaje na SD karte, ako je hudba alebo fotografie"</string>
    <string name="memory_clear_cache_title" msgid="2605096903803953619">"Vymazať dáta z vyrovnávacej pamäte?"</string>
    <string name="memory_clear_cache_message" msgid="4759561226480906588">"Týmto vymažete z pamäte dáta všetkých aplikácií."</string>
    <string name="mtp_ptp_mode_summary" msgid="7969656567437639239">"Funkcia MTP alebo PTP je aktívna"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="7694112411895701320">"Odpojiť úložisko USB?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="8251329019960361646">"Odpojiť SD kartu?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="1212025106709645023">"Ak odpojíte úložisko USB, niektoré používané aplikácie môžu byť zastavené a nebudú k dispozícii, kým úložisko USB znova nepripojíte."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="3887768438615563697">"Ak odpojíte SD kartu, niektoré používané aplikácie môžu byť zastavené a nebudú k dispozícii, kým SD kartu znova nepripojíte."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="2205587942165199845"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="2205587942165199845"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="7876201891724279436">"Úložisko USB sa nepodarilo odpojiť. Skúste to neskôr."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="2185659901137961711">"SD kartu sa nepodarilo odpojiť. Skúste to neskôr."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="5932607205977999175">"Ukladací priestor USB bude odpojený."</string>
    <string name="unmount_inform_text" product="default" msgid="716578785262713312">"SD karta bude odpojená."</string>
    <string name="sd_ejecting_title" msgid="1641122369013595273">"Odpájanie"</string>
    <string name="sd_ejecting_summary" msgid="861928572729341132">"Prebieha odpájanie"</string>
    <string name="storage_low_title" msgid="8002650511493419567">"Nedostatok ukladacieho priestoru"</string>
    <string name="storage_low_summary" msgid="7341022293583384506">"Niektoré systémové funkcie, ako je synchronizácia, nemusia fungovať správne. Skúste získať ukladací priestor odstránením alebo uvoľnením položiek, ako sú aplikácie alebo obsah médií."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Premenovať"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Pripojiť"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Odpojiť"</string>
    <string name="storage_menu_format" msgid="5454870642788909443">"Formátovať"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Naformátovať ako prenosné"</string>
    <string name="storage_menu_format_private" msgid="3208326980027382079">"Naformátovať ako interné"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Migrovať dáta"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Odstrániť záznam"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Nastaviť"</string>
    <string name="storage_menu_explore" msgid="3048031115521594488">"Preskúmať"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Uvoľniť miesto"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Spravovať úložisko"</string>
    <string name="keywords_storage_menu_free" msgid="2275406357317597106">"vymazať, ukladací priestor"</string>
    <string name="storage_title_usb" msgid="1332488715547400452">"Pripojenie USB k počítaču"</string>
    <string name="usb_connection_category" msgid="2288543238378907242">"Pripojiť ako"</string>
    <string name="usb_mtp_title" msgid="9068009584556422314">"Zariadenie pre médiá (MTP)"</string>
    <string name="usb_mtp_summary" msgid="6293240861011560842">"Umožňuje prenášať multimediálne súbory v systéme Windows alebo v systéme Mac pomocou aplikácie Android File Transfer (www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="4496529268189091846">"Fotoaparát (PTP)"</string>
    <string name="usb_ptp_summary" msgid="8382539472311655671">"Umožňuje prenos fotografií pomocou softvéru fotoaparátu a prenos akýchkoľvek súborov do počítačov, ktoré nepodporujú protokol MTP"</string>
    <string name="usb_midi_title" msgid="1139558846427981761">"MIDI"</string>
    <string name="usb_midi_summary" msgid="1842457325845863840">"Umožňuje aplikáciám s podporou rozhrania MIDI spolupracovať so softvérom MIDI na vašom počítači prostredníctvom kábla USB."</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Ďalší používatelia"</string>
    <string name="storage_internal_title" msgid="3265098802217660829">"Úložisko zariadenia"</string>
    <string name="storage_external_title" msgid="8984075540312137135">"Prenosné úložisko"</string>
    <string name="storage_volume_summary" msgid="7087627975196777994">"Využité <xliff:g id="USED">%1$s</xliff:g> z <xliff:g id="TOTAL">%2$s</xliff:g>"</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_volume_used" msgid="5031288167242496837">"Využité z <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_volume_used_total" msgid="283558499413754323">"Celkove využité z <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_mount_success" msgid="393972242641313135">"Úložisko (<xliff:g id="NAME">%1$s</xliff:g>) je pripojené"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Úložisko (<xliff:g id="NAME">%1$s</xliff:g>) sa nepodarilo pripojiť"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"Úložisko (<xliff:g id="NAME">%1$s</xliff:g>) bolo bezpečne odpojené"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Úložisko (<xliff:g id="NAME">%1$s</xliff:g>) sa nepodarilo bezpečne odpojiť"</string>
    <string name="storage_format_success" msgid="3028114521294256851">"Úložisko <xliff:g id="NAME">%1$s</xliff:g> je naformátované"</string>
    <string name="storage_format_failure" msgid="2042691589726261987">"Úložisko <xliff:g id="NAME">%1$s</xliff:g> sa nepodarilo naformátovať"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Premenujte úložisko"</string>
    <string name="storage_dialog_unmounted" msgid="1187960789775910051">"Toto úložisko (<xliff:g id="NAME_0">^1</xliff:g>) bolo bezpečné odpojené, je však stále k dispozícii. \n\nAk chcete používať toto úložisko (<xliff:g id="NAME_1">^1</xliff:g>), musíte ho najprv pripojiť."</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Toto úložisko <xliff:g id="NAME_0">^1</xliff:g> je poškodené. \n\nAk chcete používať toto úložisko (<xliff:g id="NAME_1">^1</xliff:g>), musíte ho najprv nastaviť."</string>
    <string name="storage_dialog_unsupported" msgid="7787241928013470089">"Toto zariadenie nepodporuje dané úložisko (<xliff:g id="NAME_0">^1</xliff:g>). \n\nAk chcete používať toto úložisko (<xliff:g id="NAME_1">^1</xliff:g>), musíte ho najprv nastaviť."</string>
    <string name="storage_internal_format_details" msgid="8922023528848861812">"Po naformátovaní budete môcť úložisko <xliff:g id="NAME_0">^1</xliff:g> používať s inými zariadeniami. \n\nVšetky údaje v úložisku <xliff:g id="NAME_1">^1</xliff:g> budú vymazané. Odporúčame ich najskôr zálohovať. \n\n"<b>"Zálohovanie fotiek a iných médií"</b>" \nMediálne súbory presuňte do iného úložiska v zariadení alebo ich pomocou kábla USB preneste do počítača. \n\n"<b>"Zálohovanie aplikácií"</b>" \nVšetky aplikácie v úložisku <xliff:g id="NAME_6">^1</xliff:g> sa odinštalujú a ich údaje sa vymažú. Ak si chcete tieto aplikácie ponechať, presuňte ich do iného úložiska v zariadení."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Keď toto úložisko <xliff:g id="NAME_0">^1</xliff:g> odpojíte, prestanú fungovať aplikácie, ktoré sú v ňom uložené. Mediálne súbory nebudú dostupné, kým ho opäť nepripojíte."</b>" \n\nToto úložisko <xliff:g id="NAME_1">^1</xliff:g> je naformátované tak, aby fungovalo iba v tomto zariadení."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Ak chcete použiť aplikácie, fotky a údaje, ktoré obsahuje úložisko <xliff:g id="NAME">^1</xliff:g>, opätovne ho vložte. \n\nAk zariadenie nemáte k dispozícii, môžete vybrať možnosť odstránenia záznamu tohto úložiska. \n\nAk vyberiete možnosť odstránenia záznamu, všetky údaje na danom zariadení sa navždy stratia. \n\nAplikácie môžete neskôr opätovne nainštalovať, no ich údaje uložené na tomto zariadení budú stratené."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Odstrániť úložisko <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Všetky aplikácie, fotky a údaje uložené v tomto úložisku (<xliff:g id="NAME">^1</xliff:g>) budú navždy odstránené."</string>
    <string name="storage_detail_apps" msgid="5055911985540355324">"Aplikácie"</string>
    <string name="storage_detail_images" msgid="6003883845718804371">"Obrázky"</string>
    <string name="storage_detail_videos" msgid="9079894412680404208">"Videá"</string>
    <string name="storage_detail_audio" msgid="234272983148223114">"Zvuk"</string>
    <string name="storage_detail_cached" msgid="4066364341463331199">"Dáta vo vyrovnávacej pamäti"</string>
    <string name="storage_detail_other" msgid="3821329310612285961">"Iné"</string>
    <string name="storage_detail_system" msgid="3797439069473271732">"Systém"</string>
    <string name="storage_detail_explore" msgid="13782374784415466">"Preskúmať položku <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_detail_dialog_other" msgid="3359851869961609901">"Priečinok Iné obsahuje zdieľané súbory uložené aplikáciami, súbory stiahnuté z internetu alebo prostredníctvom rozhrania Bluetooth, súbory Androidu atď. \n\nAk chcete zobraziť viditeľný obsah tohto zariadenia (<xliff:g id="NAME">^1</xliff:g>), klepnite na položku Preskúmať."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Systém obsahuje súbory používané na fungovanie Androidu verzie <xliff:g id="VERSION">%s</xliff:g>."</string>
    <string name="storage_detail_dialog_user" msgid="1691219071007313226">"<xliff:g id="USER_0">^1</xliff:g> môže mať uložené fotky, hudbu, aplikácie a ďalšie dáta, ktoré využívajú <xliff:g id="SIZE">^2</xliff:g> úložiska. \n\nAk chcete zobraziť podrobnosti, prepnite na používateľa <xliff:g id="USER_1">^1</xliff:g>."</string>
    <string name="storage_wizard_init_title" msgid="9036374223934708619">"Nastavte úložisko <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="6540132491909241713">"Použiť ako prenosné úložisko"</string>
    <string name="storage_wizard_init_external_summary" msgid="5807552934494462984">"Na prenášanie fotiek a ďalších médií medzi zariadeniami."</string>
    <string name="storage_wizard_init_internal_title" msgid="3256355049992147270">"Použiť ako interné úložisko"</string>
    <string name="storage_wizard_init_internal_summary" msgid="2283798331883929674">"Na ukladanie ľubovoľných údajov vrátane aplikácií a fotiek iba v tomto zariadení. Vyžaduje sa formátovanie, ktoré spôsobí, že nebude fungovať v iných zariadeniach."</string>
    <string name="storage_wizard_format_confirm_title" msgid="4898014527956178762">"Naformátovať ako inter. úložisko"</string>
    <string name="storage_wizard_format_confirm_body" msgid="5514665245241830772">"Preto je nutné úložisko <xliff:g id="NAME_0">^1</xliff:g> zabezpečiť pomocou formátovania. \n\nPo naformátovaní bude úložisko <xliff:g id="NAME_1">^1</xliff:g> fungovať iba v tomto zariadení. \n\n"<b>"Formátovaním vymažete všetky údaje v úložisku <xliff:g id="NAME_2">^1</xliff:g>."</b>" Ak chcete zabrániť strate údajov, odporúčame ich zálohovať."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="649252654496577680">"Formátovať ako prenosné úložisko"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="6219883780307218266">"Táto akcia vyžaduje, aby úložisko <xliff:g id="NAME_0">^1</xliff:g> bolo naformátované. \n\n"<b>"Formátovaním vymažete všetky dáta v úložisku <xliff:g id="NAME_1">^1</xliff:g>."</b>" Ak chcete zabrániť strate dát, odporúčame ich zálohovať."</string>
    <string name="storage_wizard_format_confirm_next" msgid="4412063054982084056">"Vymazať a formátovať"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formátuje sa úložisko <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Počas formátovania úložisko <xliff:g id="NAME">^1</xliff:g> neodoberajte."</string>
    <string name="storage_wizard_migrate_title" msgid="3013711737005104623">"Presuňte údaje do nov. úložiska"</string>
    <string name="storage_wizard_migrate_body" msgid="1630853797296198275">"Do tohto nového úložiska <xliff:g id="NAME">^1</xliff:g> môžete presunúť fotky, súbory a niektoré aplikácie. \n\nDoba presunu bude zhruba <xliff:g id="TIME">^2</xliff:g> a v internom úložisku sa tak uvoľní <xliff:g id="SIZE">^3</xliff:g>. Počas presunu nebudú niektoré aplikácie fungovať."</string>
    <string name="storage_wizard_migrate_now" msgid="175023718337037181">"Presunúť"</string>
    <string name="storage_wizard_migrate_later" msgid="6573789572520980112">"Presunúť neskôr"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="255346780598924540">"Presun dát"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="5039938578355576124"><b>"Doba presunu bude zhruba <xliff:g id="TIME">^1</xliff:g>. Uvoľní sa tým <xliff:g id="SIZE">^2</xliff:g> v úložisku <xliff:g id="NAME">^3</xliff:g>."</b></string>
    <string name="storage_wizard_migrate_confirm_next" msgid="217478540562501692">"Presunúť"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="462238335086734131">"Presúvajú sa údaje…"</string>
    <string name="storage_wizard_migrate_details" msgid="7474061662976940407">"Počas presunu: \n• neodpojujte <xliff:g id="NAME">^1</xliff:g>; \n• niektoré aplikácie nebudú fungovať správne; \n• udržiavajte zariadenie nabité."</string>
    <string name="storage_wizard_ready_title" msgid="3093468548660255543">"<xliff:g id="NAME">^1</xliff:g> – pripravené na použitie"</string>
    <string name="storage_wizard_ready_external_body" msgid="45040717412844114">"Teraz môžete do úložiska <xliff:g id="NAME">^1</xliff:g> ukladať fotky a ďalšie médiá."</string>
    <string name="storage_wizard_ready_internal_body" msgid="7734817996475607447">"Vaše nové úložisko <xliff:g id="NAME">^1</xliff:g> už funguje. \n\nAk chcete do tohto zariadenia presunúť fotky, súbory a údaje aplikácií, prejdite do časti Nastavenia &gt; Úložisko."</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Presuňte aplikáciu <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Presun aplikácie <xliff:g id="APP">^1</xliff:g> a jej údajov do úložiska <xliff:g id="NAME_0">^2</xliff:g> bude trvať iba chvíľu. Aplikáciu budete môcť použiť až po jej presune. \n\nÚložisko <xliff:g id="NAME_1">^2</xliff:g> počas presunu neodoberajte."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Ak chcete preniesť dáta, musíte odomknúť používateľa <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Presúva sa aplikácia <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Úložisko <xliff:g id="NAME">^1</xliff:g> počas presunu neodoberajte. \n\nAplikácia <xliff:g id="APP">^2</xliff:g> bude v tomto zariadení k dispozícii až po dokončení presunu."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="3494022998599718937">"Zrušiť presun"</string>
    <string name="storage_wizard_slow_body" msgid="8293565076885232029">"Zdá sa, že toto zariadenie (<xliff:g id="NAME_0">^1</xliff:g>) je spomalené. \n\nMôžete síce pokračovať, ale aplikácie prenesené do tohto umiestnenia sa môžu zasekávať a prenosy údajov môžu trvať dlho. \n\nZvážte použitie rýchlejšieho zariadenia (<xliff:g id="NAME_1">^1</xliff:g>) s lepšou výkonnosťou."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Ako budete používať zariadenie <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="1884468440013151482">"Ako ďalšie úložisko tabletu"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="2907833056467441047">"Iba pre aplikácie, súbory a média v tomto tablete"</string>
    <string name="storage_wizard_init_v2_internal_action" product="tablet" msgid="3278694259614995649">"Úložisko tabletu"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="5941952998075252284">"Ako ďalšie úložisko telefónu"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="3022584310096954875">"Iba pre aplikácie, súbory a média v tomto tablete"</string>
    <string name="storage_wizard_init_v2_internal_action" product="default" msgid="5645732875040797464">"Úložisko telefónu"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Alebo"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="8129096036551264207">"Použiť ako prenosné úložisko"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="6436419488235871823">"Na prenos súborov a médií medzi zariadeniami"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="781928899530539860">"Prenosné úložisko"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Nastaviť neskôr"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Formátovať úložisko <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Ak chcete ukladať aplikácie, súbory a médiá, musíte úložisko <xliff:g id="NAME_0">^1</xliff:g> naformátovať. \n\nFormátovaním vymažete existujúci obsah v úložisku <xliff:g id="NAME_1">^2</xliff:g>. Ak nechcete prísť o obsah, zálohujte ho na iné úložisko <xliff:g id="NAME_2">^3</xliff:g> alebo zariadenie."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formátovať: <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Presunúť obsah do úložiska <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4541523202790415721">"Do úložiska <xliff:g id="NAME">^1</xliff:g> môžete presunúť súbory, médiá a niektoré aplikácie. \n\nPresun bude trvať zhruba <xliff:g id="DURATION">^3</xliff:g> a uvoľníte ním <xliff:g id="SIZE">^2</xliff:g> úložiska tabletu."</string>
    <string name="storage_wizard_migrate_v2_body" product="default" msgid="809730501314645325">"Do úložiska <xliff:g id="NAME">^1</xliff:g> môžete presunúť súbory, médiá a niektoré aplikácie. \n\nPresun bude trvať zhruba <xliff:g id="DURATION">^3</xliff:g> a uvoľníte ním <xliff:g id="SIZE">^2</xliff:g> úložiska telefónu."</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"V priebehu prenosu:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Neodoberajte zariadenie <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Niektoré aplikácie nebudú fungovať"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="6111770421449869539">"Udržujte tablet nabitý"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="8826915870192535008">"Udržujte telefón nabitý"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Presunúť obsah"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Presunúť obsah neskôr"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Presúva sa obsah…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Úložisko <xliff:g id="NAME">^1</xliff:g> je pomalé"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Úložisko <xliff:g id="NAME_0">^1</xliff:g> môžete používať aj naďalej, môže však byť pomalé. \n\nAplikácie uložené v úložisku <xliff:g id="NAME_1">^2</xliff:g> nemusia fungovať správne a prenos obsahu môže trvať dlho. \n\nZvážte použitie rýchlejšieho úložiska <xliff:g id="NAME_2">^3</xliff:g> alebo využite namiesto toho jednotku <xliff:g id="NAME_3">^4</xliff:g> ako prenosné úložisko."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Začať odznova"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Ďalej"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="3896836008684280905">"Obsah môžete preniesť do zariadenia <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="5710665992219332454">"Ak chcete presunúť obsah do úložiska <xliff:g id="NAME">^1</xliff:g>, prejdite do časti "<b>"Nastavenia &gt; Úložisko"</b></string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1269878056598666852">"Obsah bol presunutý do úložiska <xliff:g id="NAME_0">^1</xliff:g>. \n\nAk chcete spravovať úložisko <xliff:g id="NAME_1">^2</xliff:g>, prejdite do časti "<b>"Nastavenia &gt; Úložisko"</b>"."</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Stav batérie"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Nabitie batérie"</string>
    <string name="apn_settings" msgid="4295467389400441299">"Prístupové body"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Upraviť prístupový bod"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Nenastavené"</string>
    <string name="apn_name" msgid="6677695784108157953">"Názov"</string>
    <string name="apn_apn" msgid="5812828833797458602">"Názov prístupového bodu"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proxy server"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Port"</string>
    <string name="apn_user" msgid="5831763936428279228">"Používateľské meno"</string>
    <string name="apn_password" msgid="7435086635953953029">"Heslo"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Proxy server systému MMS"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Port systému MMS"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Typ overenia"</string>
    <string name="apn_auth_type_none" msgid="6845031410929644238">"Žiadne"</string>
    <string name="apn_auth_type_pap" msgid="9003475621032514182">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3587713509473187621">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="6852124741245095775">"PAP alebo CHAP"</string>
    <string name="apn_type" msgid="1835573305077788773">"Typ názvu prístupového bodu"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protokol APN"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protokol APN pre roaming"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Zapnúť / vypnúť APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"Prístupový bod zapnutý"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"Prístupový bod vypnutý"</string>
    <string name="bearer" msgid="3231443241639159358">"Štandard"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Typ MVNO"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Hodnota MVNO"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Odstrániť názov prístupového bodu (APN)"</string>
    <string name="menu_new" msgid="6571230342655509006">"Nový prístupový bod"</string>
    <string name="menu_save" msgid="6611465355127483100">"Uložiť"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Zrušiť"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Pole Meno nemôže byť prázdne."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"Názov prístupového bodu (APN) nemôže byť prázdny."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"Pole MCC musí obsahovať 3 číslice."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Pole MNC musí obsahovať 2 alebo 3 číslice."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operátor zakázal pridávanie názvov prístupového bodu typu %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Prebieha obnovovanie predvolených nastavení názvu prístupového bodu (APN)."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Resetovať na predvolené"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Predvolené nastavenia APN boli obnovené."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Možnosti resetovania"</string>
    <string name="reset_dashboard_summary" msgid="4390780188264852956">"Sieť, aplikácie a zariadenie sa dajú resetovať"</string>
    <string name="reset_dashboard_summary_onlyApps" msgid="3304252260039419584">"Aplikácie sa dajú resetovať"</string>
    <string name="reset_network_title" msgid="1395494440355807616">"Resetovať Wi‑Fi, dáta a Bluetooth"</string>
    <string name="reset_network_desc" msgid="1112523764899788246">"Touto akciou obnovíte nastavenia všetkých sietí vrátane\n\n"<li>"Wi‑Fi"</li>\n<li>"mobilnej siete"</li>\n<li>"siete Bluetooth"</li></string>
    <string name="erase_euicc_data_button" msgid="728078969563311737">"Vymazať"</string>
    <string name="reset_esim_title" msgid="6152167073280852849">"Vymazať stiahnuté SIM karty"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Nezrušíte tým žiadne tarify mobilných služieb. Ak si chcete stiahnuť náhradné SIM karty, kontaktujte operátora."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Resetovať nastavenia"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Chcete resetovať všetky nastavenia sietí? Túto akciu nie je možné vrátiť späť."</string>
    <string name="reset_network_final_desc_esim" msgid="8342882682282693844">"Chcete resetovať všetky nastavenia sietí a vymazať stiahnuté SIM karty? Túto akciu nie je možné vrátiť späť."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Resetovať nastavenia"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Resetovať?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Tento používateľ nemôže resetovať nastavenia siete"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Sieťové nastavenia boli obnovené"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"SIM karty sa nedajú vymazať"</string>
    <string name="reset_esim_error_msg" msgid="4441504470684307370">"Stiahnuté SIM karty sa nedajú vymazať z dôvodu chyby.\n\nReštartujte zariadenie a skúste to znova."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Vymazať dáta (obn. výr. nast.)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Vymazať dáta (obn. výr. nast.)"</string>
    <string name="main_clear_desc" product="tablet" msgid="1651178880680056849">"Týmto vymažete všetky dáta v "<b>"internom úložisku"</b>" tabletu:\n\n"<li>"účet Google;"</li>\n<li>"dáta aj nastavenia systému a aplikácií;"</li>\n<li>"stiahnuté aplikácie."</li></string>
    <string name="main_clear_desc" product="default" msgid="6984348811887162647">"Týmto vymažete všetky dáta v "<b>"internom úložisku"</b>" telefónu:\n\n"<li>"účet Google;"</li>\n<li>"dáta aj nastavenia systému a aplikácií;"</li>\n<li>"stiahnuté aplikácie."</li></string>
    <string name="main_clear_accounts" product="default" msgid="7675859115108318537">\n\n"Momentálne ste prihlásený/-á do nasledujúcich účtov:\n"</string>
    <string name="main_clear_other_users_present" product="default" msgid="2672976674798019077">\n\n"V tomto zariadení sa nachádzajú ďalší používatelia.\n"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Hudba"</li>\n<li>"Fotky"</li>\n<li>"Iné údaje používateľa"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM karty"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Nezruší sa tým vaša tarifa mobilných služieb."</string>
    <string name="main_clear_desc_erase_external_storage" product="nosdcard" msgid="4441604184663452046">\n\n"Ak chcete vymazať hudbu, obrázky a ďalšie údaje používateľa, je treba vymazať "<b>"úložisko USB"</b>"."</string>
    <string name="main_clear_desc_erase_external_storage" product="default" msgid="1498514970618215728">\n\n"Ak chcete vymazať hudbu, obrázky a ďalšie údaje používateľa, je treba vymazať "<b>"SD kartu"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="2182181846128639635">"Vymazať ukladací priestor USB"</string>
    <string name="erase_external_storage" product="default" msgid="2610056855012660451">"Vymazať SD kartu"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="6358699244894944843">"Vymazať všetky dáta v internom úložisku USB, napríklad hudbu a fotky"</string>
    <string name="erase_external_storage_description" product="default" msgid="3367779850546310380">"Vymazať všetky dáta na SD karte, napríklad hudbu a fotky"</string>
    <string name="main_clear_button_text" product="tablet" msgid="6246087475569640671">"Vymazať všetky dáta"</string>
    <string name="main_clear_button_text" product="default" msgid="6246087475569640671">"Vymazať všetky dáta"</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Všetky vaše osobné údaje a stiahnuté aplikácie budú odstránené. Túto akciu nie je možné vrátiť späť."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Všetky vaše osobné údaje vrátane stiahnutých aplikácií a SIM kariet budú odstránené. Túto akciu nie je možné vrátiť späť."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Chcete vymazať všetky dáta?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Obnovenie výrobných nastavení nie je pre tohto používateľa k dispozícii"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Maže sa"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Čakajte…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Nastavenia hovorov"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Nastavenie hlasovej schránky, presmerovania hovorov, čakajúcich hovorov a identifikácie volajúceho"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Pripojenie cez USB"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Prenosný prístupový bod"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Pripojenie cez Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Zdieľané pripojenie"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Hotspot a tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Hotspot je zapnutý, tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Hotspot je zapnutý"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Zdieľané pripojenie"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Keď je šetrič dát zapnutý, nie je možné zdieľať dátové pripojenie ani používať prenosné hotspoty"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Iba hotspot"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Iba USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Iba Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Iba Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Hotspot, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Hotspot, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Hotspot, Ethernet"</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, Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Hotspot, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Hotspot, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Hotspot, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Hotspot, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internet sa nezdieľa s inými zariadeniami"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Zdieľanie dátového pripojenia"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Nepoužívať hotspot Wi‑Fi"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Zdieľať internet len cez USB"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Zdieľať internet len cez Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Zdieľať internet len cez Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Zdieľať internet len cez USB a Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Zdieľať internet len cez USB a Ethernet"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Zdieľať internet len cez Bluetooth a Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Zdieľať internet len cez USB, Bluetooth a Ethernet"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Pripojenie cez USB"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3168636595109044213">"Zdieľať internetové pripojenie telefónu cez USB"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="1749659335004856576">"Zdieľať internetové pripojenie tabletu cez USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Pripojenie cez Bluetooth"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="2023654677593885805">"Zdieľať internetové pripojenie tabletu cez Bluetooth"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="4322810060538179348">"Zdieľať internetové pripojenie telefónu cez Bluetooth"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="6941934844527406581">"Internetové pripojenie zariadenia <xliff:g id="DEVICE_NAME">%1$d</xliff:g> sa zdieľa cez Bluetooth"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="5292358672240161566">"Maximálny počet zariadení na zdieľanie dátového pripojenia: <xliff:g id="MAXCONNECTION">%1$d</xliff:g>."</string>
    <string name="bluetooth_untether_blank" msgid="5087548945727762308">"Ukončí sa zdieľané dát. pripojenie zariad. <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Pripojenie cez ethernet"</string>
    <string name="ethernet_tethering_subtext" product="default" msgid="5998100693350351694">"Zdieľať internetové pripojenie telefónu cez ethernet"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Hotspot a tethering umožňujú poskytovať internet iným zariadeniam prostredníctvom vášho mobilného dátového pripojenia. Aplikácie tiež môžu vytvárať hostpot na zdieľanie obsahu so zariadeniami v okolí."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Hotspot a tethering umožňujú poskytovať internet iným zariadeniam prostredníctvom vášho pripojenia Wi‑Fi alebo mobilného dátového pripojenia. Aplikácie tiež môžu vytvárať hostpot na zdieľanie obsahu so zariadeniami v okolí."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Pomocník"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobilná sieť"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Mobilný plán"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Aplikácia na SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Zmeniť aplikáciu na SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Použiť aplikáciu <xliff:g id="NEW_APP">%1$s</xliff:g> namiesto <xliff:g id="CURRENT_APP">%2$s</xliff:g> ako aplikáciu na SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Použiť aplikáciu <xliff:g id="NEW_APP">%s</xliff:g> ako aplikáciu pre SMS?"</string>
    <string name="network_scorer_picker_title" msgid="2022922801936206195">"Poskytovateľ hodnotenia siete"</string>
    <string name="network_scorer_picker_none_preference" msgid="8894034333043177807">"Žiadne"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Zmeniť aplikáciu asistent pripojenia Wi‑Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Chcete spravovať sieťové pripojenia pomocou aplikácie <xliff:g id="NEW_APP">%1$s</xliff:g> namiesto aplikácie <xliff:g id="CURRENT_APP">%2$s</xliff:g>?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Chcete spravovať sieťové pripojenia pomocou aplikácie <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Neznámy operátor SIM karty"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> nemá žiadne provízne webové stránky"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Vložte SIM kartu a reštartujte"</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Pripojte sa k internetu"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedávne žiadosti o polohu"</string>
    <string name="location_recent_location_requests_see_all" msgid="7918405176741692524">"Zobraziť všetko"</string>
    <string name="location_category_location_services" msgid="8163798686832434284">"Služby určovania polohy"</string>
    <string name="location_title" msgid="5819154746934945021">"Moja poloha"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Poloha pre pracovný profil"</string>
    <string name="location_app_level_permissions" msgid="45436724900423656">"Prístup aplikácie k polohe"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Poloha je vypnutá"</string>
    <plurals name="location_app_permission_summary_location_on" formatted="false" msgid="8286873148858526214">
      <item quantity="few"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> z(o) <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g> aplikácií majú prístup k polohe</item>
      <item quantity="many"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> of <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g> apps have access to location</item>
      <item quantity="other"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> z(o) <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g> aplikácií má prístup k polohe</item>
      <item quantity="one"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_0">%1$d</xliff:g> z <xliff:g id="TOTAL_LOCATION_APP_COUNT_1">%2$d</xliff:g> aplikácií má prístup k polohe</item>
    </plurals>
    <string name="location_category_recent_location_access" msgid="7880996987927703141">"Nedávny prístup k polohe"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Zobraziť podrobnosti"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"V poslednom čase žiadne aplikácie o polohu nepožiadali"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Polohu nedávno nepoužili žiadne aplikácie"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Vysoká spotreba batérie"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Nízka spotreba batérie"</string>
    <string name="location_scanning_screen_title" msgid="2346125609614249968">"Vyhľadávanie Wi‑Fi a Bluetooth"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Vyhľadávanie sietí Wi-Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Povoľte aplikáciám a službám kedykoľvek vyhľadávať siete Wi‑Fi, a to aj vtedy, keď je sieť Wi-Fi vypnutá. Môžete to využiť napríklad na zlepšenie funkcií a služieb podmienených polohou."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Vyhľadávanie zariadení Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Povoľte aplikáciám a službám kedykoľvek vyhľadávať zariadenia v okolí, a to aj vtedy, keď je rozhranie Bluetooth vypnuté. Môžete to využiť napríklad na zlepšenie funkcií a služieb podmienených polohou."</string>
    <string name="managed_profile_location_services" msgid="8172092734138341880">"Služby určovania polohy pre prácu"</string>
    <string name="location_time_zone_detection_screen_title" msgid="8396625087466311625">"Zisťovanie časového pásma podľa polohy"</string>
    <string name="location_time_zone_detection_enabled_title" msgid="1195178875042989835">"Zisťovanie časového pásma podľa polohy"</string>
    <string name="location_time_zone_detection_enabled_description" msgid="1064716900984397624">"Umožňuje zisťovať aktuálne časové pásmo podľa polohy zariadenia. Presnosť zisťovania časového pásma môžu ovplyvniť iné nastavenia polohy, napríklad vyhľadávanie sietí Wi‑Fi"</string>
    <string name="location_time_zone_detection_on" msgid="5514817179120761597">"Zapnuté"</string>
    <string name="location_time_zone_detection_off" msgid="192427076195667079">"Vypnuté"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="8067073548483627695">"Automatické zisťovanie časového pásma je deaktivované"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Zisťovanie časového pásma podľa polohy je deaktivované"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Zisťovanie časového pásma podľa polohy nie je podporované"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Zmeny zisťovania časového pásma podľa polohy nie sú povolené"</string>
    <string name="location_network_based" msgid="5247042890080021887">"Poloha Wi‑Fi a mobilnej siete"</string>
    <string name="location_neighborhood_level" msgid="3668890550358558267">"Povoliť apl. používať službu urč. polohy Google a rýchl. odhad. vašu polohu. Anonym. údaje o polohe sa budú odosielať spol. Google."</string>
    <string name="location_neighborhood_level_wifi" msgid="6227393490651891977">"Poloha je určená podľa siete Wi‑Fi"</string>
    <string name="location_gps" msgid="8783616672454701134">"Satelity GPS"</string>
    <string name="location_street_level" product="tablet" msgid="865953107414742784">"Umožniť aplikáciám na vašom tablete určovať polohu pomocou GPS"</string>
    <string name="location_street_level" product="default" msgid="3813836654645896185">"Umožniť aplikáciám na vašom telefóne určovať polohu pomocou GPS"</string>
    <string name="assisted_gps" msgid="1714546606018821498">"Použiť systém A-GPS"</string>
    <string name="assisted_gps_enabled" msgid="6220188450779319248">"Vylepšiť funkčnosť GPS pomocou servera (vypnutím tejto funkcie znížite využitie siete)"</string>
    <string name="assisted_gps_disabled" msgid="1062496503892849">"Vylepšiť funkčnosť GPS pomocou servera (zrušením tejto funkcie zvýšite výkon GPS)"</string>
    <string name="use_location_title" msgid="1345594777162897654">"Poloha a vyhľadávanie Google"</string>
    <string name="use_location_summary" msgid="377322574549729921">"Povoliť systému Google použiť polohu na vylepšenie výsledkov vyhľadávania a ďalších služieb"</string>
    <string name="location_access_title" msgid="4052667453826272040">"Prístup k údajom o mojej polohe"</string>
    <string name="location_access_summary" msgid="8634100005481578143">"Umožniť aplikáciám, ktoré o to požiadali, používať údaje o polohe"</string>
    <string name="location_sources_heading" msgid="6126965815860570524">"Zdroje polohy"</string>
    <string name="about_settings" product="tablet" msgid="2888705054709289693">"Informácie o tablete"</string>
    <string name="about_settings" product="default" msgid="4038626127378127613">"Informácie o telefóne"</string>
    <string name="about_settings" product="device" msgid="9012888717090302815">"O zariadení"</string>
    <string name="about_settings" product="emulator" msgid="2516560858771320366">"Informácie o emulovanom zariadení"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Zobrazuje právne informácie, stav a verziu softvéru"</string>
    <string name="legal_information" msgid="7509900979811934843">"Právne informácie"</string>
    <string name="contributors_title" msgid="7965640251547037965">"Prispievatelia"</string>
    <string name="manual" msgid="3651593989906084868">"Príručka"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Regulačné štítky"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Bezpečnostná a regulačná príručka"</string>
    <string name="copyright_title" msgid="83245306827757857">"Autorské práva"</string>
    <string name="license_title" msgid="8745742085916617540">"Licencia"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licencie aktualizácie systému Google Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Zmluvné podmienky"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Licencia systému WebView"</string>
    <string name="wallpaper_attributions" msgid="3080339190260272255">"Tapety"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Poskytovatelia satelitných snímok:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Príručka"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Pri načítavaní príručky sa vyskytla chyba."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licencie tretích strán"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Pri načítavaní licencií sa vyskytla chyba."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Načítava sa…"</string>
    <string name="settings_safetylegal_title" msgid="1334501164265709288">"Bezpečnostné informácie"</string>
    <string name="settings_safetylegal_activity_title" msgid="2218587051061093358">"Bezpečnostné informácie"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="6571695168138207587">"Nemáte dátové pripojenie. Ak chcete tieto informácie zobraziť teraz, prejdite v ľubovoľnom počítači pripojenom k internetu na adresu %s."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Načítava sa…"</string>
    <string name="lockpassword_choose_your_screen_lock_header" msgid="7587198092214670356">"Nastavenie zámky obrazovky"</string>
    <string name="lockpassword_choose_your_password_message" msgid="4474728476383676731">"Nastavte si heslo"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Ak chcete použiť odtlačok prsta, nastavte heslo"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Ak chcete použiť odtlačok prsta, nastavte vzor"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Nastavte si kód PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Ak chcete použiť odtlačok prsta, nastavte PIN"</string>
    <string name="lockpassword_choose_your_pattern_message" msgid="5815780503576680412">"Nastavte si vzor"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Znova zadajte heslo"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Zadajte pracovné heslo"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Potvrďte svoj vzor"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Zadajte pracovný vzor"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Znova zadajte kód PIN"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Zadajte pracovný PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Heslá sa nezhodujú"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Kódy PIN sa nezhodujú"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Znova nakreslite vzor"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Spôsob odomknutia"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Heslo bolo nastavené"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"Bol nastavený kód PIN"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Vzor bol nastavený"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="5359649947642749079">"Ak chcete použiť odomknutie tvárou, nastavte heslo"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="9220480399170764760">"Ak chcete použiť odomknutie tvárou, nastavte vzor"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="2285401208117502869">"Ak chcete použiť odomknutie tvárou, nastavte PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="9091792721166354172">"Biometria vyžaduje nastavenie hesla"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4949972592985176347">"Biometria vyžaduje nastavenie vzoru"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="4215367936503271941">"Biometria vyžaduje nastavenie kódu PIN"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Zabudli ste heslo?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Zabudli ste vzor?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Zabudli ste PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Ak chcete pokračovať, použite bezpečnostný vzor zariadenia"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Ak chcete pokračovať, zadajte PIN zariadenia"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Ak chcete pokračovať, zadajte heslo zariadenia"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Ak chcete pokračovať, použite pracovný bezpečnostný vzor"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Pre pokračovanie zadajte svoj pracovný PIN"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Ak chcete pokračovať, zadajte pracovné heslo"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Zadajte bezpečnostný vzor zariadenia a získajte vyššiu mieru zabezpečenia"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Zadajte kód PIN zariadenia a získajte vyššiu mieru zabezpečenia"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Zadajte heslo zariadenia a získajte vyššiu mieru zabezpečenia"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Zadajte bezpečnostný pracovný vzor a získajte vyššiu mieru zabezpečenia"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Zadajte pracovný kód PIN a získajte vyššiu mieru zabezpečenia"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Zadajte pracovné heslo a získajte vyššiu mieru zabezpečenia"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6351784282865851482">"V telefóne boli obnovené výrobné nastavenia. Ak ho chcete použiť, zadajte predchádzajúci vzor."</string>
    <string name="lockpassword_confirm_your_pin_details_frp" msgid="2128795640346033349">"V telefóne boli obnovené výrobné nastavenia. Ak ho chcete použiť, zadajte predchádzajúci PIN."</string>
    <string name="lockpassword_confirm_your_password_details_frp" msgid="4031863562975125016">"V telefóne boli obnovené výrobné nastavenia. Ak ho chcete použiť, zadajte predchádzajúce heslo."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Overenie vzoru"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Overenie kódu PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Overenie hesla"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Nesprávny kód PIN"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Nesprávne heslo"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Nesprávny vzor"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Zabezpečenie zariadenia"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Zmena bezpečnostného vzoru"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Zmena bezpečnostného kódu PIN"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Nakreslite bezpečnostný vzor"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Pomocníka zobrazíte stlačením klávesy Menu."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Na záver zdvihnite prst z obrazovky"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Spojte aspoň <xliff:g id="NUMBER">%d</xliff:g> body."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Vzor bol zaznamenaný"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Znovu nakreslite pre potvrdenie"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Váš nový bezpečnostný vzor"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Potvrdiť"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Nakresliť znova"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Vymazať"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Pokračovať"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Bezpečnostný vzor"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Vyžadovať vzor"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Obrazovku musíte odomknúť nakreslením bezpečnostného vzoru."</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Zobrazovať vzor"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Zobrazovať vzor profilu"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibrovať pri klepnutí"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Zamykať vypínačom"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Ak odomknutie nie je udržiavané funkciou <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Nastaviť bezpečnostný vzor"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Zmena bezpečnostného vzoru"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Bezpečnostný vzor obrazovky nakreslite takto"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Príliš veľa nesprávnych pokusov. Skúste to znova o <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Aplikácia nie je v telefóne nainštalovaná."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Zabezpečenie pracovného profilu"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Zámka obrazovky pre pracovný profil"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Použiť jednu zámku"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Použiť jednu zámku pre pracovný profil aj obrazovku zariadenia"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Použiť jednu zámku?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Zariadenie bude používať zámku obrazovky vášho pracovného profilu. Pracovné pravidlá sa použijú v prípade oboch zámok."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Zámka pracovného profilu nespĺňa požiadavky zabezpečenia vašej organizácie. Môžete používať rovnakú zámku pre obrazovku zariadenia aj pracovný profil, ale budú sa na ňu vzťahovať všetky pravidlá pracovnej zámky."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Použiť jednu zámku"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Použiť jednu zámku"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Rovnaká ako zámka obrazovky zariadenia"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Spravovať aplikácie"</string>
    <string name="manageapplications_settings_summary" msgid="848586372489062357">"Správa a odstraňovanie nainštalovaných aplikácií"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Informácie o aplikáciách"</string>
    <string name="applications_settings_summary" msgid="8206066893744768531">"Správa aplikácií a nastavenie rýchleho spustenia"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Nastavenia aplikácie"</string>
    <string name="install_applications" msgid="3921609656584369901">"Neznáme zdroje"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Povoliť všet. zdroje aplikácií"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Nedávno spustené aplikácie"</string>
    <plurals name="see_all_apps_title" formatted="false" msgid="6864581406735745400">
      <item quantity="few">Zobraziť všetky %1$d aplikácie</item>
      <item quantity="many">See all %1$d apps</item>
      <item quantity="other">Zobraziť všetkých %1$d aplikácií</item>
      <item quantity="one">Zobraziť všetky aplikácie</item>
    </plurals>
    <string name="forgot_password_title" msgid="3967873480875239885">"Kontaktujte správcu IT"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Môže vám pomôcť resetovať PIN, vzor alebo heslo"</string>
    <string name="install_all_warning" product="tablet" msgid="7010749217925069520">"Váš tablet a osobné dáta sú náchylnejšie na útok z neznámych aplikácií. Inštaláciou aplikácií z tohto zdroja vyjadrujete súhlas s tým, že nesiete zodpovednosť za akékoľvek poškodenie tabletu alebo stratu dát, ktoré by mohli nastať pri ich používaní."</string>
    <string name="install_all_warning" product="default" msgid="652516435709047343">"Váš telefón a osobné dáta sú náchylnejšie na útok z neznámych aplikácií. Inštaláciou aplikácií z tohto zdroja vyjadrujete súhlas s tým, že nesiete zodpovednosť za akékoľvek poškodenie telefónu alebo stratu dát, ktoré by mohli nastať pri ich používaní."</string>
    <string name="install_all_warning" product="device" msgid="2348262609815354500">"Vaše zariadenie a osobné údaje sú náchylnejšie na útok z neznámych aplikácií. Inštaláciou aplikácií z tohto zdroja vyjadrujete súhlas s tým, že nesiete zodpovednosť za akékoľvek poškodenie zariadenia alebo stratu údajov, ktoré by mohli nastať pri ich používaní."</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Rozšírené nastavenia"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Povoliť ďalšie možnosti nastavení"</string>
    <string name="application_info_label" msgid="1015706497694165866">"O aplikáciách"</string>
    <string name="storage_label" msgid="2522307545547515733">"Úložisko"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Predvolené otváranie"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Predvolené"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Kompatibilita obrazovky"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Povolenia"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Vyrovnávacia pamäť"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Vymazať vyrovnávaciu pamäť"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Vyrovnávacia pamäť"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="8212425823423508096">
      <item quantity="few">%d položky</item>
      <item quantity="many">%d položky</item>
      <item quantity="other">%d položiek</item>
      <item quantity="one">1 položka</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Zrušiť prístup"</string>
    <string name="controls_label" msgid="8671492254263626383">"Ovládacie prvky"</string>
    <string name="force_stop" msgid="2681771622136916280">"Vynútiť zastavenie"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Celkove"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Veľkosť aplikácie"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Aplikácia, úložisko USB"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Dáta používateľa"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="1054860423004751290">"Údaje ukladacieho priestoru USB"</string>
    <string name="external_data_size_label" product="default" msgid="3370825186202856353">"SD karta"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Odinštalovať"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Odinštalovať pre všetkých používateľov"</string>
    <string name="install_text" msgid="4558333621516996473">"Inštalovať"</string>
    <string name="disable_text" msgid="5146002260857428005">"Deaktivovať"</string>
    <string name="enable_text" msgid="8570798764647110430">"Povoliť"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Vymazať obsah úložiska"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Odinštalovať aktualizácie"</string>
    <string name="auto_launch_enable_text" msgid="286244432074382294">"Pre niektoré akcie ste sa rozhodli spúšťať túto aplikáciu ako predvolenú."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Tejto aplikácii ste povolili vytváranie miniaplikácií a pristupovanie k ich údajom."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Nie je predvolená pre žiadne akcie"</string>
    <string name="clear_activities" msgid="341345438786077236">"Vymazať predvolené nastavenia"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Táto aplikácia pravdepodobne nie je určená pre vašu obrazovku. Tu môžete nastaviť, ako sa aplikácia obrazovke prispôsobí."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Opýtať sa pri spustení"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Prispôsobiť veľkosť aplikácie"</string>
    <string name="unknown" msgid="8192160131923461175">"Neznáme"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Zoradiť podľa názvu"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Zoradiť podľa veľkosti"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Najnovšie"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Najčastejšie"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Spustené služby"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Vyrovnávacia pamäť"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplikácia pre tiesňové volania"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Resetovať nastavenia aplikácií"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Chcete resetovať nastavenia aplikácií?"</string>
    <string name="reset_app_preferences_desc" msgid="6509978724602405805">"Táto akcia resetuje predvoľby \n\n"<li>"zakázaných aplikácií;"</li>\n<li>"upozornení zakázaných aplikácií;"</li>\n<li>"predvolených aplikácií pre akcie;"</li>\n<li>"obmedzení dát na pozadí pre aplikácie;"</li>\n<li>"akýchkoľvek obmedzení povolení."</li>\n\n"Neprídete o žiadne dáta aplikácií."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Obnoviť aplikácie"</string>
    <string name="manage_space_text" msgid="9013414693633572277">"Správa pamäte"</string>
    <string name="filter" msgid="9039576690686251462">"Filtrovať"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Zvoľte možnosti filtra"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Všetky aplikácie"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Deaktivované aplikácie"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Stiahnuté"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Spustené"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="5140211657134608469">"Ukladací priestor USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1774499644768369891">"Na SD karte"</string>
    <string name="not_installed" msgid="5074606858798519449">"Pre tohto používateľa nenainš."</string>
    <string name="installed" msgid="2837449358488825884">"Nainštalované"</string>
    <string name="no_applications" msgid="985069304755391640">"Žiadne aplikácie."</string>
    <string name="internal_storage" msgid="999496851424448809">"Interný ukl. priestor"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Prebieha prepočítanie veľkosti..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Odstrániť dáta aplikácie?"</string>
    <string name="clear_data_dlg_text" msgid="7870723948123690332">"Všetky dáta tejto aplikácie vrátane súborov, nastavení, účtov, databáz atď. budú navždy odstránené."</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Zrušiť"</string>
    <string name="app_not_found_dlg_title" msgid="7122106240981109930"></string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Aplikáciu sa nepodarilo nájsť v zozname nainštalovaných aplikácií."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Nepodarilo sa vymazať úložisko aplikácie"</string>
    <string name="join_two_items" msgid="7893073836681382429">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> a <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_two_unrelated_items" msgid="5301233410730513655">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="computing_size" msgid="4915310659841174866">"Prebieha výpočet…"</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Nepodarilo sa vypočítať veľkosť balíčka."</string>
    <string name="version_text" msgid="7628938665256107608">"verzia <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Presunúť"</string>
    <string name="move_app_to_internal" product="tablet" msgid="5799782476959541144">"Presunúť do tabletu"</string>
    <string name="move_app_to_internal" product="default" msgid="7395498801589544372">"Presunúť do telefónu"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="1145367822171576972">"Presun. do ukl. priestoru USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="7161667212614143767">"Presunúť na SD kartu"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Už prebieha iná migrácia."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"V úložisku nie je dostatok miesta."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Aplikácia neexistuje."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Umiestnenie inštalácie nie je platné."</string>
    <string name="system_package" msgid="7559476279008519360">"Aktualizácie systému sa nepodarilo nainštalovať na externé médiá."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Aplikáciu na správu zariadenia nie je možné inštalovať na externé médiá"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Vynútiť zastavenie?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Ak vynútite zastavenie aplikácie, môže sa správať zvláštne."</string>
    <string name="app_install_location_title" msgid="8932938164156303191">"Preferované umiestnenie pre inštaláciu"</string>
    <string name="app_install_location_summary" msgid="4948270795544357021">"Zmena preferovaného umiestnenia pre inštaláciu nových aplikácií"</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Deaktivovať aplikáciu"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Ak aplikáciu deaktivujete, systém a ďalšie aplikácie už nemusia fungovať podľa očakávaní. Upozorňujeme, že túto aplikáciu nemôžete odstrániť, pretože bola vo vašom zariadení vopred nainštalovaná. Deaktiváciou ju vypnete a skryjete v zariadení."</string>
    <string name="app_disable_notifications_dlg_title" msgid="6686569904059411780">"Vypnúť upozornenia?"</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Obchod"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Podrobnosti o aplikácii"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Aplikácia bola nainštalovaná z obchodu <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Ďalšie informácie: <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Spustené"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nikdy nepoužité)"</string>
    <string name="no_default_apps" msgid="8966319676910104570">"Žiadne predvol. aplikácie"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Využitie ukl. priestoru"</string>
    <string name="storageuse_settings_summary" msgid="5001621552305431831">"Zobraziť úložisko používané aplikáciami"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Prebieha reštartovanie"</string>
    <string name="cached" msgid="5379485147573438201">"Proces na pozadí vo vyrovnávacej pamäti"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Nič nie je spustené."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Spustené aplikáciou."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"Voľné <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"Využité: <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">"Používateľ: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Odstránený používateľ"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Pamäť zariadenia"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Využitie pamäte RAM aplikáciami"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Systém"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplikácie"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Voľné"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Využité"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Vo vyr. pamäti"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Spustená aplikácia"</string>
    <string name="no_services" msgid="3898812785511572899">"Neaktívne"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Služby"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Procesy"</string>
    <string name="service_stop" msgid="5712522600201308795">"Zastaviť"</string>
    <string name="service_manage" msgid="3896322986828332075">"Nastavenia"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Táto služba bola spustená svojou aplikáciou. Ak ju zastavíte, môže dojsť k zlyhaniu aplikácie."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Túto aplikáciu nie je možné bezpečne zastaviť. Ak ju zastavíte, môže dôjsť k strate časti vašej práce."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Toto je starý proces aplikácie, ktorý stále beží pre prípad, že by ste ho znova potrebovali. Na jeho zastavenie nie je väčšinou dôvod."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: práve sa používa. Môžete ovládať po klepnutí na Nastavenia."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Hlavný proces, ktorý sa používa."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Služba <xliff:g id="COMP_NAME">%1$s</xliff:g> sa používa."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Poskytovateľ <xliff:g id="COMP_NAME">%1$s</xliff:g> sa používa."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Zastaviť systémovú službu?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="2076922609580490122">"Ak túto službu zastavíte, niektoré funkcie vášho tabletu nemusia fungovať. Ich funkčnosť sa obnoví až po vypnutí tabletu a jeho opätovnom zapnutí."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="2625863973434309085">"Ak túto službu zastavíte, niektoré funkcie vášho telefónu nemusia fungovať. Ich funkčnosť sa obnoví až po vypnutí telefónu a jeho opätovnom zapnutí."</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Jazyky, vstup a gestá"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="8670153838520237089"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="2738661322747920463"></string>
    <string name="language_input_gesture_summary_off" msgid="1604575860215661606"></string>
    <string name="language_settings" msgid="8700174277543875046">"Jazyky a vstup"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Nemáte povolenie na zmenu jazyka zariadenia."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Jazyky a vstup"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Nástroje"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Klávesnica a metódy vstupu"</string>
    <string name="phone_language" msgid="5986939176239963826">"Jazyky"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automatické nahradenie"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Opravovať pravopisné chyby"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Veľké písmená automaticky"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Prvé písmeno vo vete je automaticky veľké"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automatická interpunkcia"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Nastavenia fyzickej klávesnice"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Znak „.“ môžete vložiť dvojitým stlačením klávesu Medzerník."</string>
    <string name="show_password" msgid="7101900779571040117">"Zobrazovať heslá"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Pri písaní krátko zobrazovať zadávané znaky"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Táto kontrola pravopisu môže zhromažďovať zadávaný text vrátane osobných údajov, ako sú napríklad heslá alebo čísla kreditných kariet. Je používaná aplikáciou <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Chcete povoliť túto kontrolu pravopisu?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Nastavenia"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Jazyk"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Klávesnice"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Klávesnica na obrazovke"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Dostupná klávesnica na obrazovke"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Spravovať klávesnice na obrazovke"</string>
    <string name="keyboard_assistance_category" msgid="7320599809770932032">"Pomoc s klávesnicou"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fyzická klávesnica"</string>
    <string name="show_ime" msgid="4334255501724746849">"Používať klávesnicu na obrazovke"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Ponechať na obrazovke, keď je aktívna fyzická klávesnica"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Klávesové skratky"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="8649760728213630156">"Zobraziť dostupné klávesové skratky"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Klávesnice a nástroje pracovného profilu"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Klávesnica na obrazovke na prácu"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Predvolené"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Rýchlosť kurzora"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Herné ovládače"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Presmerovať vibrácie"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Posielať vibrácie do herného ovládača, keď je pripojený"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Zvoľte rozloženie klávesnice"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Nastaviť rozloženia klávesnice"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Prepnite klávesmi ctrl-space"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Predvolené"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Rozloženia klávesnice"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Osobný slovník"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Osobný slovník pre prácu"</string>
    <string name="user_dict_settings_summary" msgid="262228126041933459"></string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Pridať"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Pridať do slovníka"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Fráza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Viac možností"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Menej možností"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Slovo:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Skratka:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Jazyk:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Zadajte slovo"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Nepovinná skratka"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Upraviť slovo"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Upraviť"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Odstrániť"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"V používateľskom slovníku nie sú žiadne slová. Klepnutím na tlačidlo + môžete pridať slovo."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"pre všetky jazyky"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Ďalšie jazyky..."</string>
    <string name="testing" msgid="6294172343766732037">"Testovanie"</string>
    <string name="testing_phone_info" product="tablet" msgid="1910768200608214456">"Informácie o tablete"</string>
    <string name="testing_phone_info" product="default" msgid="1150527695827743906">"Informácie o telefóne"</string>
    <string name="input_methods_settings_title" msgid="7796027458321225550">"Zadávanie textu"</string>
    <string name="input_method" msgid="2982805181425436775">"Metóda vstupu"</string>
    <string name="current_input_method" msgid="3471068842881330883">"Aktuálna klávesnica"</string>
    <string name="input_method_selector" msgid="8463209725824763600">"Výber metódy vstupu"</string>
    <string name="input_method_selector_show_automatically_title" msgid="6483428482089875034">"Automaticky"</string>
    <string name="input_method_selector_always_show_title" msgid="2479533500357556146">"Vždy zobrazovať"</string>
    <string name="input_method_selector_always_hide_title" msgid="807424180027384849">"Vždy skrývať"</string>
    <string name="configure_input_method" msgid="8831343065130376880">"Nastavenie metód vstupu"</string>
    <string name="input_method_settings" msgid="4177883733022569830">"Nastavenia"</string>
    <string name="input_method_settings_button" msgid="5145039044301426311">"Nastavenia"</string>
    <string name="input_methods_settings_label_format" msgid="5809693308957109022">"Nastavenia <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="8940326108334307057">"Zvoliť aktívne metódy vstupu"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="3975358507879701606">"Nastavenia klávesnice na obrazovke"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fyzická klávesnica"</string>
    <string name="builtin_keyboard_settings_summary" msgid="4332792334499933856">"Nastavenia fyzickej klávesnice"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Vyberte modul gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Vyberte miniaplikáciu"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Vytvoriť miniaplikáciu a povoliť prístup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5694218981358874429">"Po vytvorení miniaplikácie bude môcť hostiteľ <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> získať prístup ku všetkým údajom, ktoré miniaplikácia zobrazuje."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Vždy povoliť aplikácii <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> vytvárať miniaplikácie a pristupovať k ich údajom"</string>
    <string name="usage_stats_label" msgid="6523644917803320085">"Štatistiky používania"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Štatistiky používania"</string>
    <string name="display_order_text" msgid="7120394778684605892">"Zoradiť podľa:"</string>
    <string name="app_name_label" msgid="3809910527680143673">"Aplikácia"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Naposledy použité"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Doba použitia"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Dostupnosť"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Nastavenia dostupnosti"</string>
    <string name="accessibility_settings_summary" msgid="2195085206729325737">"Čítačky obrazovky, obrazovka, doplnkové ovládanie"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Pre slabozrakých"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Zariadenie môžete prispôsobiť, aby zodpovedalo vašim potrebám. Tieto funkcie dostupnosti môžete neskôr zmeniť v Nastaveniach."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Zmeniť veľkosť písma"</string>
    <string name="screen_reader_category_title" msgid="6195867428854871553">"Čítačky obrazovky"</string>
    <string name="audio_and_captions_category_title" msgid="5049122378290004050">"Zvuk a text na obrazovke"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Zobrazenie"</string>
    <string name="accessibility_text_and_display_title" msgid="1398507755501334961">"Text a grafika"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Doplnkové ovládanie"</string>
    <string name="accessibility_tap_assistance_title" msgid="1459944158978398532">"Asistencia klepania"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Ovládanie systému"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Stiahnuté aplikácie"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Experimentálne"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Experimentálne funkcie"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Čítačka obrazovky je určená hlavne pre nevidiacich a slabozrakých ľudí"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Položky na obrazovke si môžete vypočuť nahlas klepnutím"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Nastavenia titulkov"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Zväčšenie"</string>
    <string name="accessibility_magnification_mode_title" msgid="879250866604403721">"Oblasť zväčšenia"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="4821458740248772054">"Vyberte oblasti zväčšenia, ktoré chcete pri zväčšení obrazovky používať"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Celá obrazovka"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="5630032596384610913">"Časť obrazovky"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="5139954486886669293">"Celá obrazovka a časť obrazovky"</string>
    <string name="accessibility_magnification_area_settings_full_screen" msgid="4189574224079433280">"Zväčšiť celú obrazovku"</string>
    <string name="accessibility_magnification_area_settings_window_screen" msgid="7431401975447232976">"Zväčšiť časť obrazovky"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Chcete prepnúť na tlačidlo dostupnosti?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="5291166101273060742">"Zväčšovanie častí obrazovky trojitým klepnutím môže oneskoriť zadávanie textu a ďalšie akcie.\n\nChcete prepnúť na zväčšenie tlačidlom dostupnosti?"</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Prepnúť na tlačidlo dostupnosti"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="5750910789717343646">"Ponechať zväčšenie trojitým klepnutím"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Nastavenia priblíženia"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Priblíženie trojitým klepnutím"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Priblíženie skratkou"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Priblíženie skratkou a trojitým klepnutím"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Možnosti"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Priblížte si obrazovku"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Na priblíženie trikrát klepnite"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Na priblíženie klepnite na tlačidlo"</string>
    <string name="accessibility_screen_magnification_summary" msgid="2023126829553044999">"Obrazovku si môžete rýchle priblížiť, aby ste lepšie videli jej obsah.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Postup priblíženia:&lt;/b&gt;&lt;br/&gt; 1. Skratkou spustite zväčšenie.&lt;br/&gt; 2. Klepnite na obrazovku.&lt;br/&gt; 3. Presúvaním dvoch prstov sa pohybujte po obrazovke.&lt;br/&gt; 4. Stiahnutím či roztiahnutím dvoch prstov upravte priblíženie.&lt;br/&gt; 5. Skratkou ukončite zväčšenie.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Postup dočasného priblíženia:&lt;/b&gt;&lt;br/&gt; 1. Skratkou spustite zväčšenie.&lt;br/&gt; 2. Pridržte ľubovoľné miesto na obrazovke.&lt;br/&gt; 3. Presúvaním prsta sa pohybujte po obrazovke.&lt;br/&gt; 4. Zdvihnutím prsta ukončite zväčšenie."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Keď je priblíženie zapnuté, môžete si zväčšiť obsah obrazovky.\n\n"<b>"Urobíte to tak"</b>", že spustíte priblíženie a klepnete kamkoľvek na obrazovku.\n"<ul><li>"Zobrazenie posuniete presunutím dvoch alebo viacerých prstov."</li>\n<li>"Priblíženie upravíte stiahnutím dvoch alebo viacerých prstov."</li></ul>\n\n<b>"Ak chcete obsah priblížiť krátkodobo"</b>", spustite priblíženie a pridržte ľubovoľné miesto na obrazovke.\n"<ul><li>"Po obrazovke prechádzate presunutím."</li>\n<li>"Oddialite zdvihnutím prsta."</li></ul>\n\n"Nemôžete priblížiť klávesnicu ani navigačný panel."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"<xliff:g id="CURRENT_PAGE">%1$d</xliff:g>. stránka z <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Otváranie tlačidlom dostupnosti"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Otvorte podržaním tlačidiel hlasitosti"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Otvorenie troma klepnutiami na obrazovku"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Otváranie gestom"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="8485448068531147828">"Používanie nového gesta dostupnosti"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Ak chcete použiť túto funkciu, klepnite na tlačidlo dostupnosti <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> v dolnej časti obrazovky.\n\nFunkcie prepnete pridržaním tlačidla dostupnosti."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Túto funkciu použijete tak, že pridržíte obe tlačidlá hlasitosti."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Ak chcete spustiť alebo zastaviť zväčšenie, klepnite trikrát na ľubovoľné miesto na obrazovke."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Ak chcete použiť túto funkciu, potiahnite dvoma prstami z dolnej časti obrazovky nahor.\n\nFunkcie prepnete potiahnutím dvoma prstami smerom nahor a pridržaním."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Ak chcete použiť túto funkciu, potiahnite troma prstami z dolnej časti obrazovky nahor.\n\nFunkcie prepnete potiahnutím troma prstami smerom nahor a pridržaním."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Ak chcete použiť funkciu dostupnosti, potiahnite dvoma prstami z dolnej časti obrazovky nahor.\n\nFunkcie prepnete potiahnutím dvoma prstami smerom nahor a pridržaním."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Ak chcete použiť funkciu dostupnosti, potiahnite troma prstami z dolnej časti obrazovky nahor.\n\nFunkcie prepnete potiahnutím troma prstami smerom nahor a pridržaním."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Dobre"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"<xliff:g id="SERVICE">%1$s</xliff:g> – skratka"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Tlačidlo dostupnosti"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Potiahnutie dvoma prstami nahor"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Potiahnite troma prstami nahor"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Klepnutie na tlačidlo dostupnosti"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Klepnite na tlačidlo dostupnosti <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> v dolnej časti obrazovky.\n\nFunkcie prepnete pridržaním tlačidla dostupnosti."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Potiahnite dvoma prstami z dolnej časti obrazovky nahor.\n\nFunkcie prepnete potiahnutím dvoma prstami smerom nahor a pridržaním."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Potiahnite troma prstami z dolnej časti obrazovky nahor.\n\nFunkcie prepnete potiahnutím troma prstami smerom nahor a pridržaním."</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Podržanie tlačidiel hlasitosti"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"podržanie tlačidiel hlasitosti"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Pridržte obe tlačidlá hlasitosti"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Tri klepnutia na obrazovku"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"tri klepnutia na obrazovku"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="3081710523998838305">"Rýchlo trikrát klepnite na obrazovku. Táto skratka môže zariadenie spomaliť."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Rozšírené"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Tlačidlo dostupnosti je nastavené na službu <xliff:g id="SERVICE">%1$s</xliff:g>. Ak chcete použiť priblíženie, klepnite na tlačidlo dostupnosti, podržte ho a potom vyberte priblíženie."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Gesto dostupnosti je nastavené na službu <xliff:g id="SERVICE">%1$s</xliff:g>. Ak chcete použiť priblíženie, potiahnite dvoma prstami nahor zo spodnej časti obrazovky a pridržte ich. Potom vyberte priblíženie."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Skratka klávesa hlasitosti"</string>
    <string name="accessibility_shortcut_service_title" msgid="6842883700702723355">"Služba ovládaná skratkou"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Nastavenia skratiek"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Skratka z uzamknutej obrazovky"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Môžete povoliť, aby skratka dostupnosti fungovala aj na uzamknutej obrazovke. Stačí podržať niekoľko sekúnd obidve tlačidlá hlasitosti."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Text s vysokým kontrastom"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Auto. aktualiz. priblíž. obrazovky"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Aktualizovať priblíž. obrazov. pri prechodoch apl."</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Ukončiť hovor vypínačom"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Veľký kurzor myši"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Odstrániť animácie"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Zvuk mono"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Pri prehrávaní zvuku skombinovať kanály"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Vyváženie zvuku"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Ľavé"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Pravé"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Predvolené"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekúnd"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekúnd"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minúta"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minúty"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Čas na reakciu"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Čas na reakciu"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="5283566580551714506">"Vyberte, ako dlho sa majú zobrazovať správy s výzvami na akciu, ktoré sa zobrazujú iba dočasne.\n\nNiektoré aplikácie toto nastavenie nepodporujú."</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Oneskorenie pridržania"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Inverzia farieb"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Použiť inverziu farieb"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="6955835010409034745">"Inverzia farieb stmaví svetlé obrazovky.&lt;br/&gt;&lt;br/&gt; Poznámka: &lt;ol&gt; &lt;li&gt; Inverzia farieb tiež zosvetlí tmavé obrazovky.&lt;/li&gt; &lt;li&gt; Zmenia sa farby v médiách a obrázkoch.&lt;/li&gt; &lt;li&gt; Pomocou tmavého motívu môžete zobraziť tmavé pozadie. Tmavý motív funguje s podporovanými aplikáciami. Inverzia farieb funguje vo všetkých aplikáciách.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Automatické kliknutie (čas zotrvania)"</string>
    <string name="accessibility_autoclick_description" msgid="6827042379062255307">"Automatické kliknutie funguje s pripojenou myšou. Môžete nastaviť, aby kurzor myši automaticky klikol, keď sa na určitý čas zastaví."</string>
    <string name="accessibility_autoclick_default_title" msgid="752429113115293087">"Vypnuté"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Krátke"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekundy"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Stredné"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekundy"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Dlhé"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekunda"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Vlastné"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Kratší"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Dlhší"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Čas automatického kliknutia"</string>
    <string name="accessibility_vibration_settings_title" msgid="5198184603753129450">"Vibrácie a hmatová odozva"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibrovanie pri upozornení"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibrovanie pri zvonení"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Odozva pri klepnutí"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Použiť aplikáciu <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Otvoriť <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Používať úpravu farieb"</string>
    <string name="accessibility_caption_primary_switch_title" msgid="8901149325574757370">"Zobrazenie titulkov"</string>
    <string name="accessibility_caption_primary_switch_summary" msgid="2754071646412717674">"Iba pre podporovanú aplikáciu"</string>
    <string name="captioning_caption_appearance_title" msgid="4501313548541670063">"Veľkosť a štýl titulkov"</string>
    <string name="captioning_caption_appearance_summary" msgid="7340741178479381312">"Veľkosť textu: <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Ďalšie možnosti"</string>
    <string name="accessibility_caption_preference_summary" msgid="1191356970836416954">"Tieto nastavenia titulkov nie sú podporované všetkými aplikáciami"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Tlačidlo dostupnosti"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"potiahnutie dvoma prstami z dolnej časti nahor"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Podržanie tlačidiel hlasitosti"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trojité klepnutie na obrazovku"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Ďalej"</string>
    <string name="accessibility_hearingaid_title" msgid="427173678199203191">"Načúvadlá"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="3371427366765435743">"Nie sú pripojené žiadne načúvadlá"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Pridať načúvadlá"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="8913409742121315657">"Ak chcete spárovať načúvadlá, na ďalšej obrazovke klepnite na svoje zariadenie. Skontrolujte, či sú načúvadlá v režime párovania."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"Zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> je aktívne"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="776000580683647556">
      <item quantity="few"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> uložené načúvadlá</item>
      <item quantity="many"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> saved hearing aids</item>
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> uložených načúvadiel</item>
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_0">%1$d</xliff:g> uložené načúvadlo</item>
    </plurals>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Úprava zvuku"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Skratka je zapnutá"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Vypnuté"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Zapnuté"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Vypnuté"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Nefunguje. Informácie zobrazíte klepnutím."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Táto služba nepracuje správne."</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Zobraziť v rýchlych nastaveniach"</string>
    <string name="daltonizer_type" msgid="1715154680803795947">"Režim korekcie"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="3811397143576433035">"Deuteranomália"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6787594316700223938">"Protanomália"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="1869867447813349033">"Tritanomália"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Odfarbenie"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="791173297742998942">"Červená a zelená"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="482834207025141433">"Červená a zelená"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2837137091067433059">"Modrá a žltá"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5354221071353645263">
      <item quantity="few">Krátke (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundy)</item>
      <item quantity="many">Krátke (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundy)</item>
      <item quantity="other">Krátke (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekúnd)</item>
      <item quantity="one">Krátke (<xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> sekunda)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_medium_delay" formatted="false" msgid="1550891909800510628">
      <item quantity="few">Stredné (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundy)</item>
      <item quantity="many">Stredné (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundy)</item>
      <item quantity="other">Stredné (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekúnd)</item>
      <item quantity="one">Stredné (<xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> sekunda)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="2230755548820485984">
      <item quantity="few">Dlhé (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundy)</item>
      <item quantity="many">Dlhé (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundy)</item>
      <item quantity="other">Dlhé (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekúnd)</item>
      <item quantity="one">Dlhé (<xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> sekunda)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_delay_unit_second" formatted="false" msgid="4537791441118261556">
      <item quantity="few"><xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundy</item>
      <item quantity="many"><xliff:g id="CLICK_DELAY_LABEL_2">%1$s</xliff:g> sekundy</item>
      <item quantity="other"><xliff:g id="CLICK_DELAY_LABEL_2">%1$s</xliff:g> sekúnd</item>
      <item quantity="one"><xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> sekunda</item>
    </plurals>
    <string name="accessibility_vibration_summary" msgid="27904038683405084">"Zvonenie <xliff:g id="SUMMARY_RING">%1$s</xliff:g>, upozornenie <xliff:g id="SUMMARY_NOTIFICATION">%2$s</xliff:g>, dotyk <xliff:g id="SUMMARY_TOUCH">%3$s</xliff:g>"</string>
    <string name="accessibility_vibration_summary_off" msgid="7776105450117095736">"Vibrácie pre vyzváňanie a upozornenia sú vypnuté"</string>
    <string name="accessibility_vibration_summary_low" msgid="6482721005400340317">"Pre vyzváňanie a upozornenia sú nastavené slabé vibrácie"</string>
    <string name="accessibility_vibration_summary_medium" msgid="2348889320548746469">"Pre vyzváňanie a upozornenia sú nastavené stredné vibrácie"</string>
    <string name="accessibility_vibration_summary_high" msgid="1764693979030913712">"Pre vyzváňanie a upozornenia sú nastavené silné vibrácie"</string>
    <string name="accessibility_vibration_intensity_off" msgid="972159695404061944">"Vypnuté"</string>
    <string name="accessibility_vibration_intensity_low" msgid="6311161118835287335">"Slabé"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="1734058611879392797">"Stredné"</string>
    <string name="accessibility_vibration_intensity_high" msgid="5982896399775212514">"Silné"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Nastavenia"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Zapnuté"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Vypnuté"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Ukážka"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Štandardné možnosti"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Jazyk"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Veľkosť textu"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Štýl titulkov"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Vlastné možnosti"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Farba pozadia"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Nepriehľadnosť pozadia"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Farba okna titulkov"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Nepriehľadnosť okna titulkov"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Farba textu"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Nepriehľadnosť textu"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Farba okraja"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Druh okraja"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Skupina písiem"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Titulky budú vyzerať takto."</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Predvolený"</string>
    <string name="color_title" msgid="2511586788643787427">"Farba"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Predvolené"</string>
    <string name="color_none" msgid="3703632796520710651">"Žiadna"</string>
    <string name="color_white" msgid="1896703263492828323">"Biela"</string>
    <string name="color_gray" msgid="8554077329905747877">"Sivá"</string>
    <string name="color_black" msgid="9006830401670410387">"Čierna"</string>
    <string name="color_red" msgid="5210756997426500693">"Červená"</string>
    <string name="color_green" msgid="4400462091250882271">"Zelená"</string>
    <string name="color_blue" msgid="4997784644979140261">"Modrá"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Azúrová"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Žltá"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Purpurová"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Chcete povoliť službe <xliff:g id="SERVICE">%1$s</xliff:g> úplnú kontrolu nad zariadením?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> potrebuje:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Nastavenia nemôžu overiť vašu odpoveď, pretože určitá aplikácia blokuje žiadosť o povolenie."</string>
    <string name="enable_service_encryption_warning" msgid="931082737770453755">"Ak zapnete službu <xliff:g id="SERVICE">%1$s</xliff:g>, vaše zariadenie nepoužije zámku obrazovky na zvýšenie miery šifrovania údajov."</string>
    <string name="secure_lock_encryption_warning" msgid="669152607190123579">"Keďže ste zapli služby dostupnosti, vaše zariadenie nepoužije zámku obrazovky na zvýšenie miery šifrovania údajov."</string>
    <string name="enable_service_pattern_reason" msgid="6832846117817938536">"Keďže zapnutie služby <xliff:g id="SERVICE">%1$s</xliff:g> ovplyvňuje šifrovanie údajov, musíte potvrdiť svoj vzor."</string>
    <string name="enable_service_pin_reason" msgid="6040417014360237703">"Keďže zapnutie služby <xliff:g id="SERVICE">%1$s</xliff:g> ovplyvňuje šifrovanie údajov, musíte potvrdiť svoj kód PIN."</string>
    <string name="enable_service_password_reason" msgid="6962544350351734238">"Keďže zapnutie služby <xliff:g id="SERVICE">%1$s</xliff:g> ovplyvňuje šifrovanie údajov, musíte potvrdiť svoje heslo."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"Služba <xliff:g id="SERVICE">%1$s</xliff:g> vyžaduje úplnú kontrolu nad týmto zariadením. Táto služba môže čítať obrazovku a konať v mene používateľov, ktorí vyžadujú funkcie dostupnosti. Pre väčšinu aplikácií nie je táto úroveň kontroly primeraná."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Úplná kontrola je vhodná pre aplikácie, ktoré vám pomáhajú s dostupnosťou, ale nie pre väčšinu aplikácií."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Zobrazenie a ovládanie obrazovky"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Môže čítať všetok obsah na obrazovke a zobrazovať obsah cez ďalšie aplikácie."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Zobrazenie a vykonávanie akcií"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Môže sledovať vaše interakcie s aplikáciou alebo hardvérovým senzorom a interagovať s aplikáciami za vás."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Povoliť"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Zamietnuť"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Zastaviť"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Zrušiť"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Zastaviť službu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Klepnutím na <xliff:g id="STOP">%1$s</xliff:g> zastavíte službu <xliff:g id="SERVICE">%2$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Nie sú nainštalované žiadne služby"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Nie je vybratá žiadna služba"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"K dispozícii nie je žiadny popis."</string>
    <string name="settings_button" msgid="2195468788019730377">"Nastavenia"</string>
    <string name="print_settings" msgid="8519810615863882491">"Tlač"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Vypnutá"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="1034273609054146099">
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> zapnuté tlačové služby</item>
      <item quantity="many"><xliff:g id="COUNT">%1$d</xliff:g> print services on</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> zapnutých tlačových služieb</item>
      <item quantity="one">1 zapnutá tlačová služba</item>
    </plurals>
    <plurals name="print_jobs_summary" formatted="false" msgid="3933688846338306536">
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> tlačové úlohy</item>
      <item quantity="many"><xliff:g id="COUNT">%1$d</xliff:g> tlačovej úlohy</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> tlačových úloh</item>
      <item quantity="one">1 tlačová úloha</item>
    </plurals>
    <string name="print_settings_title" msgid="7680498284751129935">"Tlačové služby"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Nie sú nainštalované žiadne služby"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Nenašli sa žiadne tlačiarne"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Nastavenia"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Pridať tlačiarne"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Zapnuté"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Vypnuté"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Pridať službu"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Pridať tlačiareň"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Hľadať"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Hľadajú sa tlačiarne"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Služba je vypnutá"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Tlačové úlohy"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Tlačová úloha"</string>
    <string name="print_restart" msgid="4424096106141083945">"Spustiť znova"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Zrušiť"</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">"Konfiguruje sa úloha <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Prebieha tlač úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Prebieha zrušenie úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Chyba tlačiarne – úloha <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Tlačiareň zablok. úlohu <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Vyhľadávacie pole je zobrazené"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Vyhľadávacie pole je skryté"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Ďalšie informácie o tejto tlačiarni"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Batéria"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Čo využíva batériu"</string>
    <string name="power_usage_not_available" msgid="3425302437465106036">"Údaje o spotrebe nie sú známe."</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">"Zostáva <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do nabitia"</string>
    <string name="background_activity_title" msgid="8214332017349791380">"Obmedzenie využívania na pozadí"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Povoliť aplikácii spúšťať sa na pozadí"</string>
    <string name="background_activity_summary_disabled" msgid="32459916080651444">"Aplikácia nemá povolené spustenie na pozadí"</string>
    <string name="background_activity_summary_allowlisted" msgid="6240154358657454651">"Používanie na pozadí sa nedá obmedziť"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Obmedziť aktivitu na pozadí?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Ak obmedzíte aktivitu aplikácie na pozadí, nemusí fungovať správne"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Aplikácia nemá nastavenú optimalizáciu batérie, preto ju nemôžete obmedziť.\n\nAk ju chcete obmedziť, zapnite optimalizáciu."</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Využitie obrazovky od úplného nabitia"</string>
    <string name="power_usage_list_summary" msgid="3237540201918492925">"Spotreba batérie od úplného nabitia"</string>
    <string name="screen_usage_summary" msgid="1393184943010909471">"Ako dlho bola zapnutá obrazovka od úplného dobitia"</string>
    <string name="device_usage_list_summary" msgid="242243537371697285">"Využitie zariadenia od úplného dobitia"</string>
    <string name="battery_since_unplugged" msgid="6991509383429936921">"Spotreba batérie od odpojenia"</string>
    <string name="battery_since_reset" msgid="2930376112877476562">"Spotreba batérie od resetovania"</string>
    <string name="battery_stats_on_battery" msgid="1553011980384645514">"<xliff:g id="TIME">%1$s</xliff:g> na batérii"</string>
    <string name="battery_stats_duration" msgid="6918768703070999743">"<xliff:g id="TIME">%1$s</xliff:g> od odpojenia"</string>
    <string name="battery_stats_charging_label" msgid="6204814386861342145">"Nabíja sa"</string>
    <string name="battery_stats_screen_on_label" msgid="8989312180491200138">"Obrazovka zapnutá"</string>
    <string name="battery_stats_gps_on_label" msgid="5626424078405382686">"GPS aktívne"</string>
    <string name="battery_stats_camera_on_label" msgid="555635201416769359">"Zapnutý fotoaparát"</string>
    <string name="battery_stats_flashlight_on_label" msgid="1621027969559427783">"Baterka je zapnutá"</string>
    <string name="battery_stats_wifi_running_label" msgid="6461551370010379049">"Wi‑Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="8115041205778441548">"Aktívny režim"</string>
    <string name="battery_stats_phone_signal_label" msgid="679649411998679555">"Signál mobilnej siete"</string>
    <!-- no translation found for battery_stats_last_duration (3088100394725340600) -->
    <skip />
    <string name="awake" msgid="5405871714019268978">"Doba používania zariadenia"</string>
    <string name="wifi_on_time" msgid="3880778525760926066">"Čas prevádzky siete Wi‑Fi"</string>
    <string name="bluetooth_on_time" msgid="8424625554628450028">"Čas prevádzky siete Wi‑Fi"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Spotreba batérie"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Podrobnosti histórie"</string>
    <!-- no translation found for advanced_battery_preference_title (6518802648205311326) -->
    <skip />
    <string name="battery_details_title" msgid="4531369291819754178">"Spotreba batérie"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Využitie"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Upraviť spotrebu energie"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Zahrnuté balíčky"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Aplikácie fungujú normálne"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="6077959765904507849">"Telefón má normálnu spotrebu batérie na pozadí"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="5063158368808711973">"Tablet má normálnu spotrebu batérie na pozadí"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="4242899844618910548">"Zariadenie má normálnu spotrebu batérie na pozadí"</string>
    <string name="battery_tip_low_battery_title" msgid="7789690720316830767">"Nízka kapacita batérie"</string>
    <string name="battery_tip_low_battery_summary" msgid="357649681960300945">"Batéria nie je schopná zaistiť dobrú výdrž"</string>
    <string name="battery_tip_smart_battery_title" product="default" msgid="2903272443772298636">"Predĺženie výdrže batérie telefónu"</string>
    <string name="battery_tip_smart_battery_title" product="tablet" msgid="6813017377960004819">"Predĺženie výdrže batérie tabletu"</string>
    <string name="battery_tip_smart_battery_title" product="device" msgid="4805599360437606335">"Predĺženie výdrže batérie zariadenia"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Zapnúť správcu batérie"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Zapnúť šetrič batérie"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Batéria sa môže minúť skôr ako obvykle"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="4413270905575486715">"Šetrič batérie je zapnutý"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Niektoré funkcie môžu byť obmedzené"</string>
    <string name="battery_tip_high_usage_title" product="default" msgid="2375953293196088319">"Telefón bol používaný viac ako obvykle"</string>
    <string name="battery_tip_high_usage_title" product="tablet" msgid="8515903411746145740">"Tablet bol používaný viac ako obvykle"</string>
    <string name="battery_tip_high_usage_title" product="device" msgid="6577086402173910457">"Zariadenie bolo používané viac ako obvykle"</string>
    <string name="battery_tip_high_usage_summary" msgid="5356399389711499862">"Batéria sa môže vybiť skôr ako obvykle"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="7152799456221596915">"Optimalizácia na zaistenie dobrého stavu batérie"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="6837061824463128857">"Batéria je dočasne obmedzená. Viac sa dozviete po klepnutí."</string>
    <string name="battery_tip_dialog_message" product="default" msgid="4681734836472195966">"Telefón sa používa viac ako obvykle. Batéria sa možno vybije skôr, ako sa očakávalo.\n\nAplikácie s najväčšou spotrebou batérie:"</string>
    <string name="battery_tip_dialog_message" product="tablet" msgid="3934298305232120382">"Tablet sa používa viac ako obvykle. Batéria sa možno vybije skôr, ako sa očakávalo.\n\nAplikácie s najväčšou spotrebou batérie:"</string>
    <string name="battery_tip_dialog_message" product="device" msgid="2620789680336796054">"Zariadenie sa používa viac ako obvykle. Batéria sa možno vybije skôr, ako sa očakávalo.\n\nAplikácie s najväčšou spotrebou batérie:"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Zahrnuje energeticky náročnú aktivitu na pozadí"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="3108195491484891588">
      <item quantity="few">Obmedziť %1$d aplikácie</item>
      <item quantity="many">Obmedziť %1$d aplikácie</item>
      <item quantity="other">Obmedziť %1$d aplikácií</item>
      <item quantity="one">Obmedziť %1$d aplikáciu</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_title" formatted="false" msgid="5862649927574803958">
      <item quantity="few">%2$d aplikácie boli nedávno obmedzené</item>
      <item quantity="many">%2$d aplikácie bolo nedávno obmedzenej</item>
      <item quantity="other">%2$d aplikácií bolo nedávno obmedzených</item>
      <item quantity="one">%1$s aplikácia bola nedávno obmedzená</item>
    </plurals>
    <plurals name="battery_tip_restrict_summary" formatted="false" msgid="3328499737453686910">
      <item quantity="few">%2$d aplikácie majú vysokú spotrebu batérie na pozadí</item>
      <item quantity="many">%2$d aplikácie má vysokú spotrebu batérie na pozadí</item>
      <item quantity="other">%2$d aplikácií má vysokú spotrebu batérie na pozadí</item>
      <item quantity="one">Aplikácia %1$s má vysokú spotrebu batérie na pozadí</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="3036853535034350991">
      <item quantity="few">Tieto aplikácie sa nedajú spustiť na pozadí</item>
      <item quantity="many">Tieto aplikácie sa nedajú spustiť na pozadí</item>
      <item quantity="other">Tieto aplikácie sa nedajú spustiť na pozadí</item>
      <item quantity="one">Táto aplikácia sa nedá spustiť na pozadí</item>
    </plurals>
    <plurals name="battery_tip_restrict_app_dialog_title" formatted="false" msgid="7897944678619251740">
      <item quantity="few">Obmedziť %1$d aplikácie?</item>
      <item quantity="many">Obmedziť %1$d aplikácie?</item>
      <item quantity="other">Obmedziť %1$d aplikácií?</item>
      <item quantity="one">Obmedziť aplikáciu?</item>
    </plurals>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Ak chcete ušetriť batériu, zakážte aplikácii <xliff:g id="APP">%1$s</xliff:g> využívať ju na pozadí. Táto aplikácia nemusí fungovať správne a upozornenia môžu byť oneskorené."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Ak chcete ušetriť batériu, zakážte týmto aplikáciám využívať ju na pozadí. Obmedzené aplikácie nemusia správne fungovať a upozornenia môžu byť oneskorené.\n\nAplikácie:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Ak chcete ušetriť batériu, zakážte týmto aplikáciám využívať ju na pozadí. Obmedzené aplikácie nemusia správne fungovať a upozornenia môžu byť oneskorené.\n\nAplikácie:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Obmedziť"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Odstrániť obmedzenie?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Aplikácia bude môcť využívať batériu na pozadí. Batéria sa môže minúť skôr, ako sa očakávalo."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Odstrániť"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Zrušiť"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="6097167058237891756">"Vaše aplikácie majú normálnu spotrebu batérie. Ak ju využívajú nadmerne, telefón vám navrhne možné opatrenia.\n\nAk vám dochádza batéria, môžete ešte vždy zapnúť šetrič batérie."</string>
    <string name="battery_tip_dialog_summary_message" product="tablet" msgid="573297655597451123">"Vaše aplikácie majú normálnu spotrebu batérie. Ak ju využívajú nadmerne, tablet vám navrhne možné opatrenia.\n\nAk vám dochádza batéria, môžete ešte vždy zapnúť šetrič batérie."</string>
    <string name="battery_tip_dialog_summary_message" product="device" msgid="8222461068860745749">"Vaše aplikácie majú normálnu spotrebu batérie. Ak ju využívajú nadmerne, zariadenie vám navrhne možné opatrenia.\n\nAk vám dochádza batéria, môžete ešte vždy zapnúť šetrič batérie."</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Správca batérie"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Spravovať aplikácie automaticky"</string>
    <string name="smart_battery_summary" product="default" msgid="1492277404000064998">"Obmedzte spotrebu batérie aplikáciami, ktoré používate zriedka"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Keď správca batérie zistí, že aplikácie nadmerne vybíjajú batériu, zobrazí sa možnosť ich obmedziť. Obmedzené aplikácie nemusia správne fungovať a upozornenia môžu byť oneskorené."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Obmedzené aplikácie"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="6059772951505411003">
      <item quantity="few">Obmedzuje sa spotreba batérie %1$d aplikáciami</item>
      <item quantity="many">Limiting battery usage for %1$d apps</item>
      <item quantity="other">Obmedzuje sa spotreba batérie %1$d aplikáciami</item>
      <item quantity="one">Obmedzuje sa spotreba batérie %1$d aplikáciou</item>
    </plurals>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Obmedzené <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3683577206409650564">"Tieto aplikácie používali batériu na pozadí. Obmedzené aplikácie nemusia správne fungovať a upozornenia môžu byť oneskorené."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Použiť správcu batérie"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Zistite, keď aplikácie nadmerne vybíjajú batériu"</string>
    <string name="battery_manager_on" product="default" msgid="3197525907390349054">"Zapnuté / zisťovanie nadmerného vybíjania batérie aplikáciami je aktívne"</string>
    <string name="battery_manager_off" msgid="673547668722420924">"Vypnuté"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="6714534362166394848">
      <item quantity="few">%1$d obmedzené aplikácie</item>
      <item quantity="many">%1$d obmedzenej aplikácie</item>
      <item quantity="other">%1$d obmedzených aplikácií</item>
      <item quantity="one">%1$d obmedzená aplikácia</item>
    </plurals>
    <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="5202575301365811053">"Pri čítaní meradla batérie sa vyskytol problém"</string>
    <string name="battery_missing_help_message" msgid="4583322687535428926">"Pri čítaní meradla batérie sa vyskytol problém. "<annotation id="url">"Viac sa dozviete"</annotation>" po klepnutí."</string>
    <string name="dialog_stop_title" msgid="5972757101865665655">"Zastaviť aplikáciu?"</string>
    <string name="dialog_stop_message" product="default" msgid="2063536418875183799">"Telefón nemôže normálne spravovať batériu, pretože aplikácia <xliff:g id="APP">%1$s</xliff:g> ho udržuje prebudený.\n\nTento problém môžete skúsiť vyriešiť tak, že aplikáciu zastavíte.\n\nAk sa to zopakuje, zrejme budete musieť aplikáciu odinštalovať, aby ste zlepšili výkonnosť batérie."</string>
    <string name="dialog_stop_message" product="tablet" msgid="426862716783569739">"Tablet nemôže normálne spravovať batériu, pretože aplikácia <xliff:g id="APP">%1$s</xliff:g> ho udržuje prebudený.\n\nTento problém môžete skúsiť vyriešiť tak, že aplikáciu zastavíte.\n\nAk sa to zopakuje, zrejme budete musieť aplikáciu odinštalovať, aby ste zlepšili výkonnosť batérie."</string>
    <string name="dialog_stop_message" product="device" msgid="4252335402634772603">"Zariadenie nemôže normálne spravovať batériu, pretože aplikácia <xliff:g id="APP">%1$s</xliff:g> ho udržuje prebudené.\n\nTento problém môžete skúsiť vyriešiť tak, že aplikáciu zastavíte.\n\nAk sa to zopakuje, zrejme budete musieť aplikáciu odinštalovať, aby ste zlepšili výkonnosť batérie."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="default" msgid="604462000476810125">"Telefón nemôže normálne spravovať batériu, pretože aplikácia <xliff:g id="APP_0">%1$s</xliff:g> ho prebúdza.\n\nTento problém môžete skúsiť vyriešiť tak, že aplikáciu <xliff:g id="APP_1">%1$s</xliff:g> zastavíte.\n\nAk sa to zopakuje, zrejme budete musieť aplikáciu odinštalovať, aby ste zlepšili výkonnosť batérie."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="tablet" msgid="7737426241260791605">"Tablet nemôže normálne spravovať batériu, pretože aplikácia <xliff:g id="APP_0">%1$s</xliff:g> ho prebúdza.\n\nTento problém môžete skúsiť vyriešiť tak, že aplikáciu <xliff:g id="APP_1">%1$s</xliff:g> zastavíte.\n\nAk sa to zopakuje, zrejme budete musieť aplikáciu odinštalovať, aby ste zlepšili výkonnosť batérie."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="device" msgid="1820679795932901383">"Zariadenie nemôže normálne spravovať batériu, pretože aplikácia <xliff:g id="APP_0">%1$s</xliff:g> ho prebúdza.\n\nTento problém môžete skúsiť vyriešiť tak, že aplikáciu <xliff:g id="APP_1">%1$s</xliff:g> zastavíte.\n\nAk sa to zopakuje, zrejme budete musieť aplikáciu odinštalovať, aby ste zlepšili výkonnosť batérie."</string>
    <string name="dialog_stop_ok" msgid="1171516542217183180">"Zastaviť aplikáciu"</string>
    <string name="dialog_background_check_title" msgid="8571605969100408762">"Vypnúť používanie aplikácie na pozadí a zastaviť ju?"</string>
    <string name="dialog_background_check_message" product="default" msgid="6203374578970183277">"Telefón nemôže normálne spravovať batériu, pretože aplikácia <xliff:g id="APP_0">%1$s</xliff:g> ho prebúdza.\n\nTento problém môžete skúsiť vyriešiť tak, že aplikáciu <xliff:g id="APP_1">%1$s</xliff:g> zastavíte a zabránite jej spúšťať sa na pozadí."</string>
    <string name="dialog_background_check_message" product="tablet" msgid="1282389215667916176">"Tablet nemôže normálne spravovať batériu, pretože aplikácia <xliff:g id="APP_0">%1$s</xliff:g> ho prebúdza.\n\nTento problém môžete skúsiť vyriešiť tak, že aplikáciu <xliff:g id="APP_1">%1$s</xliff:g> zastavíte a zabránite jej spúšťať sa na pozadí."</string>
    <string name="dialog_background_check_message" product="device" msgid="8005524265739819577">"Zariadenie nemôže normálne spravovať batériu, pretože aplikácia <xliff:g id="APP_0">%1$s</xliff:g> ho prebúdza.\n\nTento problém môžete skúsiť vyriešiť tak, že aplikáciu <xliff:g id="APP_1">%1$s</xliff:g> zastavíte a zabránite jej spúšťať sa na pozadí."</string>
    <string name="dialog_background_check_ok" msgid="5792934035264144797">"Vypnúť"</string>
    <string name="dialog_location_title" msgid="1323400468370901875">"Vypnúť prístup k polohe?"</string>
    <string name="dialog_location_message" product="default" msgid="5597959072209122057">"Telefón nemôže normálne spravovať batériu, pretože aplikácia <xliff:g id="APP">%1$s</xliff:g> stále požaduje informácie o polohe, aj keď ju práve nepoužívate.\n\nTento problém môžete skúsiť vyriešiť tak, že aplikácii vypnete prístup k polohe."</string>
    <string name="dialog_location_message" product="tablet" msgid="7165269165194599595">"Tablet nemôže normálne spravovať batériu, pretože aplikácia <xliff:g id="APP">%1$s</xliff:g> stále požaduje informácie o polohe, aj keď ju práve nepoužívate.\n\nTento problém môžete skúsiť vyriešiť tak, že aplikácii vypnete prístup k polohe."</string>
    <string name="dialog_location_message" product="device" msgid="4606829479989940464">"Zariadenie nemôže normálne spravovať batériu, pretože aplikácia <xliff:g id="APP">%1$s</xliff:g> stále požaduje informácie o polohe, aj keď ju práve nepoužívate.\n\nTento problém môžete skúsiť vyriešiť tak, že aplikácii vypnete prístup k polohe."</string>
    <string name="dialog_location_ok" msgid="6338680851382069716">"Vypnúť"</string>
    <string name="power_screen" msgid="4596900105850963806">"Obrazovka"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Baterka"</string>
    <string name="power_camera" msgid="4778315081581293923">"Fotoaparát"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi‑Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="5507921058696341513">"Pohotovostný režim mobilnej siete"</string>
    <string name="power_phone" msgid="2768396619208561670">"Hlasové hovory"</string>
    <string name="power_idle" product="tablet" msgid="4689321599298911021">"Tablet je nečinný"</string>
    <string name="power_idle" product="default" msgid="9132502722499465252">"Nečinnosť"</string>
    <string name="power_unaccounted" msgid="2160811497426475703">"Rôzne"</string>
    <string name="power_overcounted" msgid="3681101460287472876">"Nadsadená"</string>
    <string name="usage_type_cpu" msgid="8544148642836549011">"Doba prevádzky procesora"</string>
    <string name="usage_type_cpu_foreground" msgid="6120871498122604239">"CPU v popredí"</string>
    <string name="usage_type_wake_lock" msgid="3442487584173668904">"Zakázať režim spánku"</string>
    <string name="usage_type_gps" msgid="4118035982288964651">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="5573404832197356206">"Pripojenie Wi‑Fi aktívne"</string>
    <string name="usage_type_phone" product="tablet" msgid="4527092861928972130">"Tablet"</string>
    <string name="usage_type_phone" product="default" msgid="4149330237181984782">"Telefón"</string>
    <string name="usage_type_data_send" msgid="4375755152437282184">"Odoslané pakety – mobilná sieť"</string>
    <string name="usage_type_data_recv" msgid="7821924049621005218">"Prijaté pakety – mobilná sieť"</string>
    <string name="usage_type_radio_active" msgid="1876069445855950097">"Jednotka GSM je aktívna"</string>
    <string name="usage_type_data_wifi_send" msgid="6154038607322769558">"Odoslané pakety – Wi‑Fi"</string>
    <string name="usage_type_data_wifi_recv" msgid="4821128213012023100">"Prijaté pakety – Wi‑Fi"</string>
    <string name="usage_type_audio" msgid="1100651355357912864">"Zvuk"</string>
    <string name="usage_type_video" msgid="1068481638906679035">"Video"</string>
    <string name="usage_type_camera" msgid="3999579307204257822">"Fotoaparát"</string>
    <string name="usage_type_flashlight" msgid="5629235220169383309">"Baterka"</string>
    <string name="usage_type_on_time" msgid="104642441471272535">"Doba zapnutia"</string>
    <string name="usage_type_no_coverage" msgid="1385712176630900103">"Doba bez signálu"</string>
    <string name="usage_type_total_battery_capacity" msgid="3878234027503885998">"Celková kapacita batérie"</string>
    <string name="usage_type_computed_power" msgid="5191902025833668752">"Vypočítaná spotreba energie"</string>
    <string name="usage_type_actual_power" msgid="1221358930299037926">"Pozorovaná spotreba energie"</string>
    <string name="battery_action_stop" msgid="6998228610098034316">"Vynútiť zastavenie"</string>
    <string name="battery_action_app_details" msgid="7201369216798227707">"O aplikácii"</string>
    <string name="battery_action_app_settings" msgid="2437124469335488464">"Nastavenia aplikácie"</string>
    <string name="battery_action_display" msgid="6515712081248863749">"Nastavenia obrazovky"</string>
    <string name="battery_action_wifi" msgid="1829212604573932607">"Nastavenia Wi‑Fi"</string>
    <string name="battery_action_bluetooth" msgid="4723692623358386789">"Nastavenia Bluetooth"</string>
    <string name="battery_desc_voice" msgid="6900799826084022585">"Využitie batérie hlasovými hovormi"</string>
    <string name="battery_desc_standby" product="tablet" msgid="5818742458684767043">"Využitie batérie v stave nečinnosti tabletu"</string>
    <string name="battery_desc_standby" product="default" msgid="2543075041964578103">"Využitie batérie v stave nečinnosti"</string>
    <string name="battery_desc_radio" msgid="454677140485133914">"Využitie batérie jednotkou GSM"</string>
    <string name="battery_sugg_radio" msgid="5476234634503535270">"V oblastiach bez pokrytia prepnite do režimu V lietadle"</string>
    <string name="battery_desc_flashlight" msgid="6694895513133361404">"Batéria využívaná baterkou"</string>
    <string name="battery_desc_camera" msgid="6152712271731518018">"Batéria využívaná fotoaparátom"</string>
    <string name="battery_desc_display" msgid="7175017688954602685">"Využitie batérie obrazovkou a podsvietením"</string>
    <string name="battery_sugg_display" msgid="3102137296547788111">"Znížte jas obrazovky alebo časový limit obrazovky"</string>
    <string name="battery_desc_wifi" msgid="5276669172548928768">"Využitie batérie sieťou Wi‑Fi"</string>
    <string name="battery_sugg_wifi" msgid="359757575108350109">"Vypnite pripojenie Wi‑Fi, keď sa sieť Wi‑Fi nepoužíva alebo keď nie je k dispozícii"</string>
    <string name="battery_desc_bluetooth" msgid="2237947137783306282">"Využitie batérie technológiou Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="8943564578546832037">"Keď technológiu Bluetooth nepoužívate, vypnite ju"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="6495519793211758353">"Skúste sa pripojiť k inému zariadeniu Bluetooth"</string>
    <string name="battery_desc_apps" msgid="4187483940383266017">"Využitie batérie aplikáciou"</string>
    <string name="battery_sugg_apps_info" msgid="4796917242296658454">"Zastavte aplikáciu alebo ju odinštalujte"</string>
    <string name="battery_sugg_apps_gps" msgid="7221335088647925110">"Vyberte režim úspory batérie"</string>
    <string name="battery_sugg_apps_settings" msgid="6527223370162382166">"Aplikácia môže ponúkať nastavenia na zníženie spotreby batérie"</string>
    <string name="battery_desc_users" msgid="1959428568888686847">"Využitie batérie používateľom"</string>
    <string name="battery_desc_unaccounted" msgid="1649497860893660763">"Rôzna spotreba energie"</string>
    <string name="battery_msg_unaccounted" msgid="5647345548624995064">"Využitie batérie je približný údaj o spotrebe energie a nezahrnuje každý zdroj využívajúci batériu. Režim Rôzne predstavuje rozdiel medzi vypočítanou spotrebou energie a skutočnou pozorovanou spotrebou batérie."</string>
    <string name="battery_desc_overcounted" msgid="5982079150027267539">"Nadsadená spotreba energie"</string>
    <string name="mah" msgid="3604527474433227780">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="6401552215008504483">"Používané <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="4416277218863232476">"Aktívna <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Využitie obrazovky <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> využila aplikácia <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> celkovej výdrže batérie"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Prehľad od posledného úplného nabitia"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Posledné úplné nabitie"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Úplné nabitie vydrží približne"</string>
    <string name="battery_footer_summary" msgid="9125397752380281832">"Údaje o spotrebe batérie sú približné a môžu sa meniť podľa spôsobu používania"</string>
    <string name="battery_detail_foreground" msgid="3312280147931093967">"Pri aktívnom používaní"</string>
    <string name="battery_detail_background" msgid="3333915023706228000">"Na pozadí"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Spotreba batérie"</string>
    <string name="battery_detail_info_title" msgid="5896661833554333683">"Od úplného dobitia"</string>
    <string name="battery_detail_manage_title" msgid="7910805419446927887">"Správa spotreby batérie"</string>
    <string name="advanced_battery_graph_subtext" msgid="6816737986172678550">"Odhad zostávajúcej batérie vychádza z vášho používania zariadenia"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Odhadovaný zostávajúci čas:"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Do úplného dobitia"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Odhad sa môže líšiť v závislosti od intenzity využitia"</string>
    <string name="menu_stats_unplugged" msgid="7125297366200634285">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> od odpojenia"</string>
    <string name="menu_stats_last_unplugged" msgid="230678127178268655">"Pri poslednom odpojení pre <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="2713445396954503670">"Využitie batérie celkom"</string>
    <string name="menu_stats_refresh" msgid="6727628139586938835">"Obnoviť"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Mediaserver"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimalizácia aplikácií"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Šetrič batérie"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Zapnúť automaticky"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Žiadny plán"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Podľa vášho bežného správania"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Podľa percent"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Ak je pravdepodobné, že sa batéria pred opätovným pripojením do siete vybije, zapne sa šetrič batérie."</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Zapne sa na úrovni <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Nastavenie plánu"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Predĺženie výdrže batérie"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Vypnúť pri nabití"</string>
    <string name="battery_saver_sticky_description_new" product="default" msgid="4969508893424116609">"Šetrič batérie sa vypne, keď sa telefón nabije nad <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="tablet" msgid="6613068787945311001">"Šetrič batérie sa vypne, keď sa tablet nabije nad <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="device" msgid="8707774542183385479">"Šetrič batérie sa vypne, keď sa zariadenie nabije nad <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Zapnúť"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Používať Šetrič batérie"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Zapínať automaticky"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nikdy"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"pri <xliff:g id="PERCENT">%1$s</xliff:g> batérie"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Percentá batérie"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Zobrazovať percentá v stavovom riadku"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Štatistiky procesov"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Podrobné štatistiky spustených procesov"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Využitie pamäte"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"Využité miesto za posled. <xliff:g id="TIMEDURATION">%3$s</xliff:g>: <xliff:g id="USEDRAM">%1$s</xliff:g> z <xliff:g id="TOTALRAM">%2$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"Počas <xliff:g id="TIMEDURATION">%2$s</xliff:g> sa použilo <xliff:g id="PERCENT">%1$s</xliff:g> RAM"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Na pozadí"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Na popredí"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Vo vyr. pamäti"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"OS Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Natívne"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Jadro"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Vyrovnávacie pamäte"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Využitie RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Využitie RAM (pozadie)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Spustené"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Procesy"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Služby"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Trvanie"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Podrobnosti o pamäti"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 hodiny"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 hodín"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 hodín"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 deň"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Zobraziť systémové"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Skryť systémové"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Zobraziť percentá"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Použiť Uss (jedinečnú veľkosť súpravy)"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Typ štatistík"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Na pozadí"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Na popredí"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Vo vyr. pamäti"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Hlasový vstup a výstup"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Nastavenia hlasového vstupu a výstupu"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Hlasové vyhľadávanie"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Klávesnica Android"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Nastavenia hlasového vstupu"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Hlasový vstup"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Služby hlasového vstupu"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Úplná aktivácia kľúčových slov a interakcia"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Jednoduchý prevod reči na text"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Táto služba hlasového vstupu bude môcť neustále monitorovať hlas a ovládať za vás aplikácie so zapnutým hlasovým vstupom. Pochádza z aplikácie <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Chcete povoliť používanie tejto služby?"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Preferovaný nástroj"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Nastavenia nástroja"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Rýchlosť reči a výška hlasu"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Nástroj"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Hlasy"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Hovorený jazyk"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Inštalácia hlasov"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Ak chcete nainštalovať hlasy, otvorte aplikáciu <xliff:g id="TTS_APP_NAME">%s</xliff:g>"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Otvoriť aplikáciu"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Zrušiť"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Resetovať"</string>
    <string name="tts_play" msgid="2945513377250757221">"Prehrať"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Adaptácia pripojenia"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Predĺži výdrž batérie a zvýši výkonnosť zariadenia automatickým spravovaním pripojení k sieti"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Úložisko poverení"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Inštalovať certifikát"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="6644116499934553975">"Inštalovať certifikáty z úložiska"</string>
    <string name="credentials_install_summary" product="default" msgid="8161351950524166012">"Inštalovať certifikáty z SD karty"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Vymazať poverenia"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Odstrániť všetky certifikáty"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Dôveryhodné poverenia"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Zobraziť dôveryhodné certifikáty CA"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Poverenia používateľa"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Zobraziť a zmeniť uložené poverenia"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Rozšírené"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Poverenia nie sú pre tohto používateľa k dispozícii"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Nainštalované pre sieť VPN a aplikácie"</string>
    <string name="credential_for_wifi" msgid="1963335263280604998">"Nainštalované pre sieť Wi‑Fi"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Chcete odstrániť všetok obsah?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Úložisko poverení bolo vymazané"</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Úlož. poverení nemožno vymazať"</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Prístup k dátam o používaní"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Certifikát CA"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Certifikát použív. VPN a apl."</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Certifikát Wi‑Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Vaše údaje nebudú súkromné"</string>
    <string name="ca_certificate_warning_description" msgid="3386740654961466569">"Certifikáty CA využívajú weby, aplikácie a siete VPN na šifrovanie. Inštalujte iba certifikáty CA od organizácií, ktorým dôverujete. \n\n Ak si nainštalujete certifikát CA, vlastník certifikátu by mohol získať prístup k vašim údajom, napríklad k heslám, či podrobnostiam kreditnej karty z webov alebo aplikácií, ktoré používate, a to aj vtedy, ak sú vaše údaje šifrované."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Neinštalovať"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Inštalovať aj tak"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Certifikát nie je nainštalovaný"</string>
    <string name="request_manage_credentials_title" msgid="4524504926699928916">"Chcete aplikácii <xliff:g id="APP_NAME">%s</xliff:g> povoliť inštalovať certifikáty v tomto zariadení?"</string>
    <string name="request_manage_credentials_description" msgid="4969609158022551952">"Tieto certifikáty vás identifikujú aplikáciám a webovým adresám uvedeným nižšie"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Nepovoliť"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Povoliť"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Zobraziť viac"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Aplik. na správu certifikátov"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Žiadne"</string>
    <string name="certificate_management_app_description" msgid="7257420502179110164">"Certifikáty nainštalované touto aplikáciou vás identifikujú pre aplikácie a webové adresy uvedené nižšie"</string>
    <string name="remove_credential_management_app" msgid="6879631067380232928">"Odstrániť"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Signál núdzového vytáčania"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Nastaviť správanie pri tiesňovom volaní"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Zálohovanie"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Zapnuté"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Vypnuté"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Zálohovať a obnoviť"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Osobné údaje"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Zálohovať moje dáta"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Zálohovať dáta aplikácií, heslá Wi‑Fi a ďalšie nastavenia na serveroch Google"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Zálohovací účet"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Správa záložného účtu"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Zahrnúť dáta aplikácií"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automaticky obnovovať"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Pri preinštalovaní aplikácie obnoviť zálohované nastavenia a dáta"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Služba zálohovania nie je aktívna"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Momentálne nie sú záložné údaje ukladané do žiadneho účtu"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Chcete zastaviť zálohovanie hesiel Wi‑Fi, záložiek, ďalších nastavení a dát aplikácií? Chcete vymazať všetky kópie na serveroch Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Chcete zastaviť zálohovanie dát zariadenia (ako sú heslá Wi‑Fi a história hovorov) a dát aplikácií (ako sú nastavenia a súbory uložené aplikáciami)? Chcete vymazať všetky kópie na vzdialených serveroch?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Automaticky vzdialene zálohujte údaje zariadenia (napr. heslá do sietí Wi‑Fi a históriu hovorov) a údaje aplikácií (napr. nastavenia a súbory uložené aplikáciami). \n\nKeď zapnete automatické zálohovanie, údaje zariadenia a aplikácií sa budú pravidelne vzdialene ukladať. Údaje aplikácie môžu byť ľubovoľné informácie uložené aplikáciou (na základe nastavení vývojára) aj potenciálne citlivé údaje, ako sú kontakty, správy a fotky."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Nastavenia správcu zariadenia"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Aplikácia na správu zariadenia"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deaktivovať túto aplikáciu na správu zariadenia"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Odinštalovať aplikáciu"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deaktivovať a odinštalovať"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Aplikácie na správu zariadenia"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"K dispozícii nie sú žiadne aplikácie na správu zariadenia"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Nie sú k dispozícii žiadne agenty dôvery"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Aktivovať aplikáciu na správu zariadenia?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktivovať túto aplikáciu na správu zariadenia"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Správca zariadenia"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Aktiváciou tejto aplikácie na správu zariadenia umožníte aplikácii <xliff:g id="APP_NAME">%1$s</xliff:g> vykonávať nasledujúce operácie:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Toto zariadenie bude spravovať a monitorovať aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Aplikácia na správu zariadenia je aktívna a umožňuje aplikácii <xliff:g id="APP_NAME">%1$s</xliff:g> vykonávať nasledujúce operácie:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Aktivovať aplikáciu Správca profilu?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Chcete povoliť dohľad?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Ak budete pokračovať, vášho používateľa bude spravovať správca, ktorý bude môcť okrem vašich osobných údajov ukladať tiež združené údaje.\n\nSprávca môže sledovať a spravovať nastavenia, prístup, aplikácie a údaje priradené k tomuto používateľovi (vrátane aktivity siete a informácií o polohe vášho zariadenia)."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Ďalšie možnosti zakázal váš správca."</string>
    <string name="admin_more_details" msgid="6698424974827333973">"Ďalšie podrobnosti"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Denník upozornení"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"História upozornení"</string>
    <string name="notification_history_today" msgid="5828496957208237230">"Posledných 24 hodín"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Odložené"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Nedávno zavreté"</string>
    <plurals name="notification_history_count" formatted="false" msgid="1859304685071321991">
      <item quantity="few"><xliff:g id="NUMBER_1">%d</xliff:g> upozornenia</item>
      <item quantity="many"><xliff:g id="NUMBER_1">%d</xliff:g> notifications</item>
      <item quantity="other"><xliff:g id="NUMBER_1">%d</xliff:g> upozornení</item>
      <item quantity="one"><xliff:g id="NUMBER_0">%d</xliff:g> upozornenie</item>
    </plurals>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Tón zvonenia a vibrovanie"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Podrobnosti siete"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Synchronizácia je povolená"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Synchronizácia bola zakázaná"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Synchronizuje sa…"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Chyba synchronizácie"</string>
    <string name="sync_failed" msgid="3806495232114684984">"Synchronizácia zlyhala"</string>
    <string name="sync_active" msgid="5787407579281739975">"Synchronizácia je aktívna"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Synchronizácia"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Vyskytli sa problémy so synchronizáciou. Služba bude čoskoro obnovená."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Pridať účet"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Pracovný profil zatiaľ nie je k dispozícii"</string>
    <string name="work_mode_label" msgid="1001415270126064436">"Pracovný profil"</string>
    <string name="work_mode_on_summary" msgid="2042885311126239961">"Spravované vašou organizáciou"</string>
    <string name="work_mode_off_summary" msgid="4044568753909036134">"Aplikácie a upozornenia sú vypnuté"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Odstrániť pracovný profil"</string>
    <string name="background_data" msgid="321903213000101158">"Dátové prenosy na pozadí"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Aplikácie môžu kedykoľvek synchronizovať, odosielať a prijímať údaje"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Vypnúť prenosy na pozadí?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Vypnutie dátových prenosov na pozadí šetrí batériu a znižuje spotrebu dát. Niektoré aplikácie môžu používať dátové prenosy na pozadí aj napriek tomuto nastaveniu."</string>
    <string name="sync_automatically" msgid="4874122892765430304">"Automatická synch. údajov aplikácií"</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Synchronizácia zapnutá"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Synchronizácia vypnutá"</string>
    <string name="sync_error" msgid="846923369794727644">"Chyba synchronizácie"</string>
    <string name="last_synced" msgid="1527008461298110443">"Posledná synchronizácia <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Synchronizuje sa…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Zálohovať nastavenia"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Zálohovať moje nastavenia"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Synchronizovať"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Zrušiť synchronizáciu"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Klepnutím synchronizujete (<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">"Kalendár"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontakty"</string>
    <string name="sync_plug" msgid="7956982719077985381"><font fgcolor="#ffffffff">"Víta vás služba Google Sync"</font>" \nSpoločnosť Google pomocou nej synchronizuje údaje a umožňuje vám tak pristupovať ku kontaktom, stretnutiam a ďalším informáciám, nech ste kdekoľvek."</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Nastavenia synchronizácie aplikácie"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Údaje a synchronizácia"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Zmeniť heslo"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Nastavenia účtu"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Odstrániť účet"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Pridať účet"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Chcete účet odstrániť?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="8893801622174947887">"Odstránením účtu odstránite z tabletu aj všetky správy, kontakty a ďalšie údaje tohto účtu."</string>
    <string name="really_remove_account_message" product="default" msgid="1217810840427479274">"Odstránením účtu odstránite z telefónu aj všetky správy, kontakty a ďalšie údaje tohto účtu."</string>
    <string name="really_remove_account_message" product="device" msgid="5241756807386611084">"Odstránením účtu odstránite zo zariadenia aj všetky správy, kontakty a ďalšie údaje tohto účtu."</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Správca túto zmenu zakázal"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Nie je možné ručne synchronizovať"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Synchronizácia tejto položky je momentálne zakázaná. Ak chcete toto nastavenie zmeniť, dočasne zapnite dátové prenosy na pozadí a automatickú synchronizáciu."</string>
    <string name="enter_password" msgid="6327051330258595331">"Ak chcete spustiť Android, zadajte heslo."</string>
    <string name="enter_pin" msgid="1029287617551232681">"Ak chcete spustiť Android, zadajte číslo PIN."</string>
    <string name="enter_pattern" msgid="1747316785866742960">"Ak chcete spustiť Android, nakreslite vzor."</string>
    <string name="cryptkeeper_wrong_pattern" msgid="340747269176120242">"Nesprávny vzor"</string>
    <string name="cryptkeeper_wrong_password" msgid="7295607881887114486">"Nesprávne heslo"</string>
    <string name="cryptkeeper_wrong_pin" msgid="2347961593970714201">"Nesprávny kód PIN"</string>
    <string name="checking_decryption" msgid="6111642972615688237">"Kontroluje sa…"</string>
    <string name="starting_android" msgid="6694154070215356186">"Spúšťa sa systém Android..."</string>
    <string name="delete" msgid="8330605554706263775">"Odstrániť"</string>
    <string name="misc_files" msgid="6598066985800749585">"Rôzne súbory"</string>
    <string name="misc_files_selected_count" msgid="5597802791672749532">"vybraté: <xliff:g id="NUMBER">%1$d</xliff:g> z <xliff:g id="TOTAL">%2$d</xliff:g>"</string>
    <string name="misc_files_selected_count_bytes" msgid="7622766714974500289">"<xliff:g id="NUMBER">%1$s</xliff:g> z <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="7898929601615536401">"Vybrať všetko"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Spotreba dát"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobilné dáta a Wi‑Fi"</string>
    <string name="data_usage_accounting" msgid="6832015632699116754">"Účtovanie dát operátorom sa môže líšiť od údajov zariadenia."</string>
    <string name="data_usage_app" msgid="6367974637783240699">"Využitie aplikáciami"</string>
    <string name="data_usage_app_info_label" msgid="3542220416056122841">"O APLIKÁCII"</string>
    <string name="data_usage_cellular_data" msgid="1917226172511825849">"Mobilné dáta"</string>
    <string name="data_usage_data_limit" msgid="1120291692444009289">"Nastaviť dátový limit"</string>
    <string name="data_usage_cycle" msgid="6875568429140150029">"Cyklus spotreby dát"</string>
    <string name="data_usage_app_items_header_text" msgid="7513812163443595033">"Využitie aplikáciami"</string>
    <string name="data_usage_menu_roaming" msgid="6864561338842056939">"Dátový roaming"</string>
    <string name="data_usage_menu_restrict_background" msgid="1414574366645086133">"Obmedziť prenosy na pozadí"</string>
    <string name="data_usage_menu_allow_background" msgid="6242931073390680432">"Povoliť prenosy na pozadí"</string>
    <string name="data_usage_menu_split_4g" msgid="3391899816926640583">"Samostatné použitie 4G"</string>
    <string name="data_usage_menu_show_wifi" msgid="6380926350184939975">"Zobraziť využitie Wi‑Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="4694889089278302691">"Skryť využitie Wi‑Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="4401026240876938859">"Zobraziť využitie siete Ethernet"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="7792365022467586772">"Skryť využitie Ethernetu"</string>
    <string name="data_usage_menu_metered" msgid="4279260736172851951">"Obmedzenia siete"</string>
    <string name="data_usage_menu_auto_sync" msgid="2632694000068175025">"Automaticky synchronizovať údaje"</string>
    <string name="data_usage_menu_sim_cards" msgid="8966135605336735887">"SIM karty"</string>
    <string name="data_usage_cellular_data_summary" msgid="8139993171126153316">"Pozastavené na limite"</string>
    <string name="account_settings_menu_auto_sync" msgid="1660484779001900562">"Autom. synchronizovať dáta"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Autom. synchr. osobných údajov"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Autom. synchr. pracov. údajov"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Zmeniť cyklus..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Deň v mesiaci, kedy sa má resetovať cyklus spotreby:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"V tomto období nevyužili dátové pripojenie žiadne aplikácie."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Na popredí"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Na pozadí"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"obmedzené"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Chcete vypnúť mobilné dáta?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Nastaviť dát. limit mobil. sietí"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Nastaviť dátový limit siete 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Nastaviť dát. limit sietí 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Nastaviť dát. limit Wi‑Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi‑Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobilné"</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">"Mobilné"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Žiadne"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobilné dáta"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"Dátové prenosy 2G a 3G"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"Dátové prenosy 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Na popredí:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Na pozadí:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Nastavenia aplikácie"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Dátové prenosy na pozadí"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Povoliť používanie mobilných dát na pozadí"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Nastav. dát. limitu mob. siete obmedzíte údaje na poz. pre apl."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Obmedziť prenosy na pozadí?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Ak budú k dispozícii len mobilné siete, môže táto funkcia spôsobiť, že aplikácie, ktoré údaje na pozadí vyžadujú, nebudú fungovať.\n\nVhodnejšie spôsoby ovládania využívania údajov nájdete v nastaveniach aplikácie."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Obmedzenie dátových prenosov na pozadí je možné len v prípade, že ste nastavili dátový limit pre mobilnú sieť."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Zapnúť automatatickú synch. údajov?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="6387714350903085918">"Zmeny, ktoré v rámci svojich účtov vykonáte na webe, sa automaticky skopírujú do tabletu.\n\nNiektoré účty tiež automaticky skopírujú na web akékoľvek zmeny vykonané v tablete. Týmto spôsobom funguje napríklad účet Google."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="6457107552266187107">"Zmeny, ktoré v rámci svojich účtov vykonáte na webe, sa automaticky skopírujú do telefónu.\n\nNiektoré účty tiež automaticky skopírujú na web akékoľvek zmeny vykonané v telefóne. Týmto spôsobom funguje napríklad účet Google."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Vypnúť automatickú synch. údajov?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Toto nastavenie šetrí spotrebu dát a batérie. Na získanie najnovších informácií však budete musieť každý účet synchronizovať ručne. Nebudete tiež dostávať upozornenia na dostupné aktualizácie."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Dátum resetovania cyklu spotreby"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Dátum v každom mesiaci:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Nastaviť"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Upozornenie na spotrebu dát"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Limit spotreby dát"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Obmedzenie spotreby dát"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="6000062970083379466">"Po dosiahnutí nastaveného limitu váš tablet vypne mobilné dátové pripojenie.\n\nKeďže spotrebu dát meria tablet, ale váš operátor môže spotrebu vyčísliť inak, je vhodné si nastaviť nižší limit."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="4942895670789168024">"Po dosiahnutí nastaveného limitu váš telefón vypne mobilné dátové pripojenie.\n\nKeďže spotrebu dát meria telefón, ale váš operátor môže spotrebu vyčísliť inak, je vhodné nastaviť si nižší limit."</string>
    <string name="data_usage_restrict_background_title" msgid="2745551538820692821">"Obmedziť prenosy na pozadí?"</string>
    <string name="data_usage_restrict_background" msgid="1893102079135282794">"Ak obmedzíte mobilné dáta na pozadí, niektoré aplikácie a služby nebudú fungovať, dokým sa nepripojíte k sieti Wi‑Fi."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="5588623586867665419">"Ak obmedzíte mobilné dáta na pozadí, niektoré aplikácie a služby nebudú fungovať, dokým sa nepripojíte k sieti Wi‑Fi.\n\nToto nastavenie platí pre všetkých používateľov tabletu."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="6402714504088590463">"Ak obmedzíte mobilné dáta na pozadí, niektoré aplikácie a služby nebudú fungovať, dokým sa nepripojíte k sieti Wi‑Fi.\n\nToto nastavenie platí pre všetkých používateľov telefónu."</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">"upozorn."</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">"limit"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Odstránené aplikácie"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Odstránené aplikácie a používatelia"</string>
    <string name="data_usage_received_sent" msgid="1486740779864806124">"Prijaté: <xliff:g id="RECEIVED">%1$s</xliff:g> Odoslané: <xliff:g id="SENT">%2$s</xliff:g>"</string>
    <string name="data_usage_total_during_range" msgid="2695893609573024612">"<xliff:g id="RANGE">%2$s</xliff:g>: využitých približne <xliff:g id="TOTAL">%1$s</xliff:g>."</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="45300375132284265">"<xliff:g id="RANGE">%2$s</xliff:g>: podľa meraní tabletu využitých asi <xliff:g id="TOTAL">%1$s</xliff:g>. Operátor môže využitie dát účtovať inak."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="3183594094081558193">"<xliff:g id="RANGE">%2$s</xliff:g>: podľa meraní telefónu využitých asi <xliff:g id="TOTAL">%1$s</xliff:g>. Operátor môže využitie dát účtovať inak."</string>
    <string name="data_usage_metered_title" msgid="6421347352444253058">"Obmedzenia siete"</string>
    <string name="data_usage_metered_body" msgid="1206840367501998582">"Keď sú dátové prenosy na pozadí obmedzené, zaobchádzame s meranými sieťami rovnako ako s mobilnými. Pred sťahovaním veľkých súborov pomocou týchto sietí vás môžu aplikácie upozorniť."</string>
    <string name="data_usage_metered_mobile" msgid="3514227339274396401">"Mobilné siete"</string>
    <string name="data_usage_metered_wifi" msgid="4807465959110473407">"Merané siete Wi‑Fi"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="4664158157415362613">"Ak chcete vybrať merané siete, zapnite Wi‑Fi."</string>
    <string name="data_usage_metered_auto" msgid="1560514082131687116">"Automaticky"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Využitie siete"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Merané"</string>
    <string name="data_usage_metered_no" msgid="1685828958417926268">"Nemerané"</string>
    <string name="data_usage_disclaimer" msgid="3271450299386176770">"Účtovanie dát operátorom sa môže líšiť od údajov zariadenia."</string>
    <string name="cryptkeeper_emergency_call" msgid="8369322820475703306">"Tiesňové volanie"</string>
    <string name="cryptkeeper_return_to_call" msgid="3857250752781151232">"Späť na hovor"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Názov"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Typ"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Adresa servera"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"Šifrovanie PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"Tajný kľúč L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Identifikátor protokolu IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Predzdieľaný kľúč protokolu IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Používateľský certifikát protokolu IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Certifikát CA protokolu IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Certifikát servera IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Zobraziť rozšírené možnosti"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"Vyhľadávacie domény DNS"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"Servery DNS (napr. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Presmerovávacie trasy (napr. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Používateľské meno"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Heslo"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Uložiť informácie o účte"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(nepoužité)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(neoverovať server)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(prijatý zo servera)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Tento typ siete VPN nemôže zostať neustále pripojený"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Vždy zapnuté siete VPN podporujú iba numerické adresy serverov"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Vždy zapnuté siete VPN musia mať uvedený server DNS"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Vždy zapnuté siete VPN musia mať numerické adresy serverov DNS"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Zadané informácie nepodporujú vždy zapnuté siete VPN"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Zrušiť"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Zavrieť"</string>
    <string name="vpn_save" msgid="683868204634860888">"Uložiť"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Pripojiť"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Nahradiť"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Upraviť profil VPN"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Zabudnúť"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Pripojiť k profilu <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Odpojiť tento profil VPN?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Odpojiť"</string>
    <string name="vpn_version" msgid="41856553718304367">"Verzia <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Zabudnúť profil VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Nahradiť existujúcu sieť VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Nastaviť sieť VPN, ktorá je vždy zapnutá?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Keď je toto nastavenie zapnuté, nebudete mať internetové pripojenie, dokým sa úspešne nenadviaže pripojenie VPN"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Súčasná sieť VPN bude nahradená a nebudete mať internetové pripojenie, dokým sa úspešne nenadviaže pripojenie VPN"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"K sieti VPN, ktorá je vždy zapnutá, ste sa už pripojili. Ak sa pripojíte k inej sieti, vaša súčasná sieť VPN bude nahradená a vypne sa režim vždy zapnutej siete."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"K sieti VPN ste sa už pripojili. Ak sa pripojíte k inej sieti, vaša súčasná sieť VPN bude nahradená."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Zapnúť"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> nie je možné pripojiť"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Táto aplikácia nepodporuje siete VPN, ktoré sú vždy zapnuté"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Pridať profil siete VPN"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Upraviť profil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Odstrániť profil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Vždy zapnutá VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Neboli pridané žiadne siete VPN"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Udržiavať neustále pripojenie k sieti VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Nepodporované touto aplikáciou"</string>
    <string name="vpn_always_on_summary_active" msgid="2532123735674813569">"Vždy zapnuté VPN je aktívne"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Blokovať pripojenia bez siete VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Vyžadovať pripojenie VPN?"</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Vyberte profil VPN, ku ktorému chcete mať vždy pripojenie. Sieťová premávka bude povolená len v prípade pripojenia k tejto sieti VPN."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Žiadna"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Vždy zapnutá sieť VPN vyžaduje adresu IP pre server aj DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Nie je k dispozícii žiadne sieťové pripojenie. Skúste to neskôr."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Odpojiť od siete VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Žiadne"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Chýba certifikát. Skúste upraviť profil."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Systém"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Používateľ"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Deaktivovať"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Povoliť"</string>
    <string name="trusted_credentials_remove_label" msgid="8975881053042174913">"Odstrániť"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Dôverovať"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Povoliť systémový certifikát CA?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Zakázať systémový certifikát CA?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Natrvalo odstrániť používateľský certifikát CA?"</string>
    <string name="credential_contains" msgid="407972262032275476">"Obsah záznamu:"</string>
    <string name="one_userkey" msgid="4417212932385103517">"jeden kľúč používateľa"</string>
    <string name="one_usercrt" msgid="1865069301105101370">"jeden certifikát používateľa"</string>
    <string name="one_cacrt" msgid="7467796501404158399">"jeden certifikát CA"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"certifikáty CA (%d)"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Podrobnosti o povereniach"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Odstránené poverenie: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Nie sú nainštalované žiadne poverenia používateľa"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Kontrola pravopisu"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Kontrola pravopisu pre prácu"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Tu zadajte aktuálne heslo pre úplné zálohy"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Tu zadajte nové heslo pre úplné zálohy"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Tu zadajte znova nové heslo pre úplné zálohy"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Nastaviť heslo"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Zrušiť"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Ďalšie aktualizácie systému"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Sieť môže byť monitorovaná"</string>
    <string name="done_button" msgid="6269449526248267">"Hotovo"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="5491460811755938449">
      <item quantity="few">Nastavte certifikáty ako dôveryhodné alebo ich odstráňte</item>
      <item quantity="many">Nastavte certifikáty ako dôveryhodné alebo ich odstráňte</item>
      <item quantity="other">Nastavte certifikáty ako dôveryhodné alebo ich odstráňte</item>
      <item quantity="one">Nastavte certifikát ako dôveryhodný alebo ho odstráňte</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message_device_owner" formatted="false" msgid="2788832560436163252">
      <item quantity="few">Doména <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> nainštalovala na vaše zariadenie certifikačné autority, ktoré jej umožnia monitorovať aktivitu v sieti zariadenia vrátane pošty, aplikácií a zabezpečených webov.\n\nĎalšie informácie o týchto certifikátoch získate od svojho správcu.</item>
      <item quantity="many">Doména <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> nainštalovala na vaše zariadenie certifikačné autority, ktoré jej umožnia monitorovať aktivitu v sieti zariadenia vrátane pošty, aplikácií a zabezpečených webov.\n\nĎalšie informácie o týchto certifikátoch získate od svojho správcu.</item>
      <item quantity="other">Doména <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> nainštalovala na vaše zariadenie certifikačné autority, ktoré jej umožnia monitorovať aktivitu v sieti zariadenia vrátane pošty, aplikácií a zabezpečených webov.\n\nĎalšie informácie o týchto certifikátoch získate od svojho správcu.</item>
      <item quantity="one">Doména <xliff:g id="MANAGING_DOMAIN_0">%s</xliff:g> nainštalovala na vaše zariadenie certifikačnú autoritu, ktorá jej umožní monitorovať aktivitu v sieti zariadenia vrátane pošty, aplikácií a zabezpečených webov.\n\nĎalšie informácie o tomto certifikáte získate od svojho správcu.</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message" formatted="false" msgid="3989916958347169622">
      <item quantity="few">Doména <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> nainštalovala pre váš pracovný profil certifikačné autority, ktoré jej môžu umožniť monitorovať aktivitu v pracovnej sieti vrátane pošty, aplikácií a zabezpečených webov.\n\nĎalšie informácie o týchto certifikátoch získate od svojho správcu.</item>
      <item quantity="many">Doména <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> nainštalovala pre váš pracovný profil certifikačné autority, ktoré jej môžu umožniť monitorovať aktivitu v pracovnej sieti vrátane pošty, aplikácií a zabezpečených webov.\n\nĎalšie informácie o týchto certifikátoch získate od svojho správcu.</item>
      <item quantity="other">Doména <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> nainštalovala pre váš pracovný profil certifikačné autority, ktoré jej môžu umožniť monitorovať aktivitu v pracovnej sieti vrátane pošty, aplikácií a zabezpečených webov.\n\nĎalšie informácie o týchto certifikátoch získate od svojho správcu.</item>
      <item quantity="one">Doména <xliff:g id="MANAGING_DOMAIN_0">%s</xliff:g> nainštalovala pre váš pracovný profil certifikačnú autoritu, ktorá jej môže umožniť monitorovať aktivitu v pracovnej sieti vrátane pošty, aplikácií a zabezpečených webov.\n\nĎalšie informácie o tomto certifikáte získate od svojho správcu.</item>
    </plurals>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Vaša aktivita v sieti, vrátane e-mailov, aplikácií a zabezpečených webov môže byť monitorovaná treťou stranou.\n\nUmožňujú to dôveryhodné poverenia nainštalované vo vašom zariadení."</string>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="125941406175485894">
      <item quantity="few">Overiť certifikáty</item>
      <item quantity="many">Overiť certifikáty</item>
      <item quantity="other">Overiť certifikáty</item>
      <item quantity="one">Overiť certifikát</item>
    </plurals>
    <string name="user_settings_title" msgid="6550866465409807877">"Viacerí používatelia"</string>
    <string name="user_settings_footer_text" product="device" msgid="7523914344521302179">"Zdieľajte zariadenie tak, že pridáte nových používateľov. Jednotliví používatelia majú v zariadení osobný priestor pre vlastné plochy, účty, aplikácie, nastavenia a ďalšie položky."</string>
    <string name="user_settings_footer_text" product="tablet" msgid="3730074318510244552">"Zdieľajte tablet tak, že pridáte nových používateľov. Jednotliví používatelia majú v tablete osobný priestor pre vlastné plochy, účty, aplikácie, nastavenia a ďalšie položky."</string>
    <string name="user_settings_footer_text" product="default" msgid="4420915712050349125">"Zdieľajte telefón tak, že pridáte nových používateľov. Jednotliví používatelia majú v telefóne osobný priestor pre vlastné plochy, účty, aplikácie, nastavenia a ďalšie položky."</string>
    <string name="user_list_title" msgid="1387379079186123404">"Používatelia a profily"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Pridať používateľa alebo profil"</string>
    <string name="user_add_user_menu" msgid="6395904234221724625">"Pridať používateľa"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Obmedzený profil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Nenastavené"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Nie je nastavený – obmedzený profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Pracovný profil (nie je nastavený)"</string>
    <string name="user_admin" msgid="4024553191395768119">"Správca"</string>
    <string name="user_you" msgid="3070562015202859996">"Vy (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="5739771048517070983">"Môžete pridať až <xliff:g id="USER_COUNT">%1$d</xliff:g> používateľov"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="3405022988077682357">"Používateľov môže spravovať iba vlastník tabletu."</string>
    <string name="user_cannot_manage_message" product="default" msgid="6434662649769855494">"Používateľov môže spravovať iba vlastník telefónu."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Profily s obmedzeniami nemôžu pridávať účty"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Odstrániť zo zariadenia (<xliff:g id="USER_NAME">%1$s</xliff:g>)"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Nastavenia uzamknutej obrazovky"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Pridávať používateľov z uzamknutej obrazovky"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Chcete odstrániť svoj profil?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Chcete odstrániť používateľa?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Odstrániť tento profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Odstrániť pracovný profil?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="439222554798995592">"Prídete o svoj priestor a dáta v tomto tablete. Táto akcia sa nedá vrátiť späť."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="5991495192044543230">"Prídete o svoj priestor a dáta v tomto telefóne. Táto akcia sa nedá vrátiť späť."</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Všetky aplikácie a dáta budú odstránené."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Ak budete pokračovať, všetky aplikácie a údaje v tomto profile budú odstránené."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Všetky aplikácie a dáta budú odstránené."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Pridáv. nového používateľa..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Odobrať používateľa"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Odstrániť"</string>
    <string name="user_guest" msgid="4545590092001460388">"Hosť"</string>
    <string name="user_clear_guest_menu" msgid="4864362688187480452">"Vymazať údaje hosťa"</string>
    <string name="user_exit_guest_menu" msgid="5064400453222497734">"Ukončiť reláciu hosťa"</string>
    <string name="user_exit_guest_confirm_title" msgid="7526978959527761497">"Chcete ukončiť reláciu hosťa?"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Všetky aplikácie a údaje v tejto relácii budú odstránené."</string>
    <string name="user_exit_guest_dialog_remove" msgid="8095094235815676847">"Ukončiť reláciu"</string>
    <string name="user_enable_calling" msgid="264875360626905535">"Zapnúť telefonické hovory"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Zapnúť telefonáty a SMS"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Odobrať používateľa"</string>
    <string name="user_enable_calling_confirm_title" msgid="7868894792723368364">"Zapnúť telefonické hovory?"</string>
    <string name="user_enable_calling_confirm_message" msgid="4924965198409050155">"S týmto používateľom sa bude zdieľať história hovorov."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Zapnúť telefonické hovory a správy SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"S týmto používateľom sa bude zdieľať história hovorov a správ SMS."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Tiesňové informácie"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Informácie a kontakty používateľa <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Povoliť aplikácie a obsah"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Aplikácie s obmedzením"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Rozbaliť nastavenia aplikácie"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Bezkontaktné platby"</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Ako to funguje"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Plaťte v obchodoch telefónom"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Predvolená platobná aplikácia"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Nenastavené"</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="788899906312142803">"Použiť predvolenú aplikáciu"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Vždy"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Okrem prípadov, keď je spustená iná platobná aplikácia"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Pri bezkontaktnom termináli zaplatiť pomocou aplikácie:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Platenie pri termináli"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Nastavte si platobnú aplikáciu. Potom iba priložte zadnú časť vášho telefónu k akémukoľvek terminálu so symbolom pre bezkontaktné platby."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Dobre"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Viac…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Nastavenie predvolenej platobnej aplikácie"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Aktualizácia predvolenej platobnej aplikácie"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Pri bezkontaktnom termináli zaplaťte pomocou aplikácie <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Pri bezkontaktnom termináli zaplaťte pomocou aplikácie <xliff:g id="APP_0">%1$s</xliff:g>.\n\nNahradí sa tým vaša predvolená platobná aplikácia <xliff:g id="APP_1">%2$s</xliff:g>."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Nastaviť ako predvolené"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Aktualizovať"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Obmedzenia"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Odstrániť obmedzenia"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Zmeniť kód PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Pomocník a spät. väzba"</string>
    <string name="support_summary" msgid="1034146931237148885">"Články pomocníka, telefón a čet, začíname"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Účet pre obsah"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID fotografie"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Extrémne hrozby"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Prijímať upozornenia na extrémne ohrozenie života a majetku"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Závažné hrozby"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Prijímať upozornenia na závažné ohrozenie života a majetku"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Upozornenia Amber"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Prijímať bulletiny o únosoch detí"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Opakovať"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Povoliť nástroj Správca hovorov"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Povoliť tejto službe spravovať spôsob uskutočňovania hovorov."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Správca hovorov"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Bezdrôtové núdzové upozornenia"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Sieťoví operátori"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Názvy prístupových bodov"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Rozšírené volanie"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Volanie cez 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="6776190202179584104">"Používať na zlepšenie hlasovej a inej komunikácie LTE (odporúčané)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="7814006095552641136">"Používať na zlepšenie hlasovej a inej komunikácie služby 4G (odporúčané)"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Odosielať kontakty operátorovi"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Odosielajte telefónne čísla svojich kontaktov na poskytovanie rozšírených funkcií"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Chcete odosielať kontakty operátorovi <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Chcete odosielať kontakty svojmu operátorovi?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Telefónne čísla vašich kontaktov budú pravidelne odosielané operátorovi <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Tieto informácie určujú, či vaše kontakty môžu používať určité funkcie, napríklad videohovory alebo niektoré funkcie správ."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Telefónne čísla vašich kontaktov budú pravidelne odosielané vášmu operátorovi.<xliff:g id="EMPTY_LINE">

</xliff:g>Tieto informácie určujú, či vaše kontakty môžu používať určité funkcie, napríklad videohovory alebo niektoré funkcie správ."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Preferovaný typ siete"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (odporúčané)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Správy MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Odosielať aj prijímať, keď sú mobilné dáta deaktivované"</string>
    <string name="data_during_calls_title" msgid="3940276893360429144">"Dáta počas hovorov"</string>
    <string name="data_during_calls_summary" msgid="2289050189544214759">"Používať túto SIM kartu na mobilné dáta iba počas hovorov"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Pracovná SIM karta"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Prístup k aplikáciám a obsahu"</string>
    <string name="user_rename" msgid="8735940847878484249">"PREMENOVAŤ"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Nastaviť obmedzenia aplikácií"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Riadi: <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Táto aplikácia má prístup k vašim účtom"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Táto aplikácia má prístup k vašim účtom. Riadené aplikáciou <xliff:g id="APP">%1$s</xliff:g>."</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Siete Wi‑Fi a mobilné siete"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Povoliť úpravu nastavení sietí Wi‑Fi a mobilných sietí"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Povoliť úpravy párovania a nastavení rozhrania Bluetooth"</string>
    <string name="restriction_nfc_enable_title" msgid="525512312298242911">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="8065688740509581028">"Povoliť výmenu dát, ak sa toto zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> dotýka iného zariadenia s funkciou NFC"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="6397567147629410131">"Povoliť výmenu dát, ak sa tablet dotýka iného zariadenia"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="3331800894734678808">"Povoliť výmenu dát, ak sa telefón dotýka iného zariadenia"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Poloha"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Povoliť aplikáciám používať informácie o polohe"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Späť"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Ďalej"</string>
    <string name="wizard_finish" msgid="4220258401946825946">"Dokončiť"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_setup_wizard_title" msgid="3945520353564138219">"SIM karty"</string>
    <string name="sim_settings_title" msgid="8392862852842113531">"SIM karty"</string>
    <string name="sim_settings_summary" msgid="5777472623476930332">"<xliff:g id="SIM_NAME">%1$s</xliff:g> – <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7726897488921853655">"SIM karty boli vymenené"</string>
    <string name="sim_cards_changed_message_summary" msgid="7338082681445213621">"Klepnutím nastavíte aktivity"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobilné dáta nie sú k dispozícii"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Klepnutím vyberiete dátovú SIM kartu"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Vždy používať pre hovory"</string>
    <string name="select_sim_for_data" msgid="1577092784244587369">"Vyberte SIM kartu pre údaje"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Vybrať SIM kartu pre SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Prepínajú sa dátové SIM karty, môže to chvíľu trvať…"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Volať pomocou služby"</string>
    <string name="sim_select_card" msgid="1226182454109919045">"Výber SIM karty"</string>
    <string name="sim_card_number_title" msgid="4728780444646439845">"SIM karta <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_editor_name" msgid="5900178038499314621">"Názov SIM karty"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Zadajte názov SIM karty"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Slot pre SIM kartu %1$d"</string>
    <string name="sim_editor_carrier" msgid="2424593350691002557">"Operátor"</string>
    <string name="sim_editor_number" msgid="3209002966895156006">"Číslo"</string>
    <string name="sim_editor_color" msgid="9067029630083892961">"Farba SIM karty"</string>
    <string name="sim_card_select_title" msgid="8146523005929848793">"Vybrať SIM kartu"</string>
    <string name="color_orange" msgid="216547825489739010">"Oranžová"</string>
    <string name="color_purple" msgid="6603701972079904843">"Purpurová"</string>
    <string name="sim_no_inserted_msg" msgid="7272710974813741735">"Nie sú vložené žiadne SIM karty"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Stav SIM karty"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Stav SIM karty (%1$d. slot na SIM kartu)"</string>
    <string name="sim_call_back_title" msgid="4274099761123657464">"Volať späť z predvolenej SIM karty"</string>
    <string name="sim_outgoing_call_title" msgid="7759080345748128897">"SIM karta pre odchádzajúce hovory"</string>
    <string name="sim_other_call_settings" msgid="5956308869284958883">"Ďalšie nastavenia hovorov"</string>
    <string name="preferred_network_offload_title" msgid="6453199586512609557">"Preferované zaťaž. siete"</string>
    <string name="preferred_network_offload_header" msgid="4842188794016376899">"Zakázať vysiel. názvu siete"</string>
    <string name="preferred_network_offload_footer" msgid="374984523082849648">"Zakázaním vysielania názvu siete zabránite tretím stranám v zobrazení informácií o svojej sieti."</string>
    <string name="preferred_network_offload_popup" msgid="3949937898807213370">"Zakázaním vysielania názvu siete zabránite automatického pripojeniu ku skrytým sieťam."</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="584752983048661108">"SIM karty boli zmenené."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Klepnutím prejdete do Nastavení"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Vždy sa opýtať"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Vyžaduje sa výber"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Výber SIM karty"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Nastavenia"</string>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="6585075562837786847">
      <item quantity="few">Zobraziť %d skryté položky</item>
      <item quantity="many">Zobraziť %d skrytej položky</item>
      <item quantity="other">Zobraziť %d skrytých položiek</item>
      <item quantity="one">Zobraziť %d skrytú položku</item>
    </plurals>
    <string name="network_dashboard_title" msgid="788543070557731240">"Sieť a internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="4020746665765996480">"mobilné"</string>
    <string name="network_dashboard_summary_data_usage" msgid="2531133412846140766">"spotreba dát"</string>
    <string name="network_dashboard_summary_hotspot" msgid="3798394197274240682">"hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Pripojené zariadenia"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, režim v aute, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, režim v aute"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</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, režim v aute, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, režim v aute"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</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">"Nie je k dispozícii, pretože technológia NFC je vypnutá"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Pred použitím nainštalujte platobnú aplikáciu"</string>
    <string name="app_and_notification_dashboard_title" msgid="2861781687031832943">"Aplikácie a upozornenia"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Nedávne aplikácie, predvolené aplikácie"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Prístup k upozorneniam nie je k dispozícii pre aplikácie v pracovnom profile."</string>
    <string name="account_dashboard_title" msgid="2735150283267749852">"Účty"</string>
    <string name="account_dashboard_default_summary" msgid="2025250151574540063">"Neboli pridané žiadne účty"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Predvolené aplikácie"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Jazyky, gestá, čas, záloha"</string>
    <string name="search_results_title" msgid="3360639917793022533">"Nastavenia"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, sieťové pripojenie, internet, bezdrôtové, dáta, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Upozornenie Wi‑Fi, upozornenie wifi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"spotreba dát"</string>
    <string name="keywords_vibrate_on_touch" msgid="8379369786860641429">"Zastaviť vibrovanie, klepnutie, klávesnica"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Používať 24-hodinový formát"</string>
    <string name="keywords_storage_files" msgid="4509695858659705198">"Stiahnuť"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Otvoriť v aplikácii"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Aplikácie"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"časové pásmo"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Záhlavie četu, systém, upozornenie, okno, dialógové okno, zobrazenie, nad inými aplikáciami, vykreslenie"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Svietidlo, svetlo, baterka"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, prepínač, ovládanie"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobilné, mobil, mobilný operátor, bezdrôtové, dáta, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, hovor, volanie"</string>
    <string name="keywords_display" msgid="874738809280751745">"obrazovka, dotyková obrazovka"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"stlmiť obrazovku, dotyková obrazovka, batéria, svetlá"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"stlmiť obrazovku, noc, tónovanie, nočný režim, jas, farba obrazovky, farba, farby"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"pozadie, prispôsobenie, prispôsobiť obrazovku"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"veľkosť textu"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"premietanie, prenos, zrkadlenie obrazovky, zdieľanie obrazovky, zrkadlenie, zdieľať obrazovku, prenášanie obrazovky"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"miesto, disk, pevný disk, zariadenie, využitie"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"spotreba energie, nabíjanie"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"pravopis, slovník, kontrola pravopisu, automatické opravy"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"rozpoznávač, vstup, reč, hovoriť, jazyk, súprava hands-free, hand free, rozpoznávanie, nevhodné, slovo, zvuk, história, náhlavná súprava bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"sadzba, jazyk, predvolené, reč, hovoriť, tts, dostupnosť, čítačka, zrakovo postihnutí"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"čas, vojenský"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"resetovať, obnoviť, továrenské nastavenia"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"trvale vymazať, odstrániť, obnoviť, vymazať, odobrať, obnoviť výrobné nastavenia"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"tlačiareň"</string>
    <string name="keywords_sounds" msgid="1850691834585575875">"zvukový signál reproduktora, reproduktor, hlasitosť, vypnúť zvuk, stíšenie, zvuk, hudba"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"nie, nerušiť, vyrušiť, vyrušenie, prerušenie"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"nablízku, poloha, história, nahlasovanie, GPS"</string>
    <string name="keywords_accounts" msgid="3482052586502133909">"účet, pridanie účtu, pracovný profil, pridať účet"</string>
    <string name="keywords_users" msgid="3497517660077620843">"obmedzenie, obmedziť, obmedzené"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"oprava textu, opraviť, zvuk, vibrácie, automatický výber, jazyk, gesto, navrhnúť, návrh, motív, urážlivé slovo, typ, emodži, medzinárodné"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"resetovať, nastavenia, predvolené"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"aplikácie, sťahovanie, aplikácie, systém"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"aplikácie, povolenia, bežpečnosť"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"aplikácie, predvolené"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorovať optimalizácie, spánok, pohotovostný režim aplikácie"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"sýta, RGB, sRGB, farba, naturálna, štandardná"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"farby, teplota, D65, D73, biela, žltá, modrá, teplá, studená"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"odomknúť prejdením prstom, heslo, vzor, pin"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"pripnutie obrazovky"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"pracovná výzva, práca, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"pracovný profil, spravovaný profil, zjednotiť, zjednotenie, práca, profil"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gestá"</string>
    <string name="keywords_cards_passes" msgid="4798102029412153067">"platobné karty, lístky"</string>
    <string name="keywords_device_controls" msgid="8962494082504033651">"ovládanie zariadení, ovládanie"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"platiť, klepnutie, platby"</string>
    <string name="keywords_backup" msgid="707735920706667685">"záloha, zálohovanie"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"gesto"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"tvár, odomknutie, overenie totožnosti, prihlásenie"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, verzia prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="8784456547742075508">"sieť, stav mobilnej siete, stav služby, sila signálu, typ mobilnej siete, roaming, iccid, eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"sériové číslo, hardvérová verzia"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"úroveň opráv zabezpečenia androidu, verzia základného pásma, verzia jadra"</string>
    <string name="keywords_dark_ui_mode" msgid="6465231409128452489">"motív, svetlý, tmavý režim"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tmavý motív"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"chyba"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Ambientné zobrazenie, zobrazenie uzamknutej obrazovky"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"upozornenie na uzamknutej obrazovke, upozornenia"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"tvár"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"odtlačok prsta, pridať odtlačok prsta"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"stmavenie obrazovky, dotyková obrazovka, batéria, inteligentný jas, dynamický jas, automatický jas"</string>
    <string name="keywords_display_adaptive_sleep" msgid="8003895686008403685">"stlmiť obrazovku, spánok, batéria, časový limit, vnímavá, zobrazenie, obrazovka, nečinnosť"</string>
    <string name="keywords_auto_rotate" msgid="7914655570000378975">"otočiť, prevrátiť, rotovať, na výšku, na šírku, orientácia, zvisle, vodorovne"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"inovovať, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"nerušiť, rozpis, upozornenia, blokovať, stíšiť, vibrovať, spánok, práca, sústredenie, zvuk, vypnúť zvuk, deň, pracovný deň, víkend, noc pracovného dňa, udalosť"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"obrazovka, čas uzamknutia, časový limit, uzamknutá obrazovka"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"pamäť, vyrovnávacia pamäť, údaje, odstrániť, vymazať, voľné, miesto"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"pripojené, zariadenie, slúchadlá, slúchadlá s mikrofónom, reproduktor, bezdrôtové, párovať, slúchadlá do uší, hudba, médiá"</string>
    <string name="keywords_wallpaper" msgid="6712776876474488023">"pozadie, obrazovka, uzamknutá obrazovka, motív"</string>
    <string name="keywords_styles" msgid="6312134005271042434">"tvar ikony, zvýrazňujúca farba, písmo"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"predvolené, asistent"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"platby, predvolené"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"prichádzajúce upozornenie"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"tethering cez usb, tethering cez bluetooth, wi-fi, hotspot"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"hmatová spätná väzba, vibrovať, obrazovka, citlivosť"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"hmatová spätná väzba, vibrovanie, telefón, hovor, citlivosť, zvonenie"</string>
    <string name="keywords_notification_vibration" msgid="9162262178415439951">"hmatová spätná väzba, vibrovanie, citlivosť"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"šetrič batérie, pevne umiestnené, trvalé, šetrič energie, batéria"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"postup, plán, šetrič batérie, šetrič energie, batéria, automaticky, percento"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"VoLTE, rozšírené hovory, volanie cez 4g"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"pridať jazyk, pridať určitý jazyk"</string>
    <string name="keywords_font_size" msgid="336803136451166298">"veľkosť textu"</string>
    <string name="default_sound" msgid="6604374495015245195">"Predvolený zvuk"</string>
    <string name="sound_settings_summary" msgid="944761906531715109">"Hlasitosť zvonenia a upozornení je na <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Hlasitosť, vibrovanie, režim bez vyrušení"</string>
    <string name="sound_settings_summary_vibrate" msgid="7192223433295988890">"Zvonenie je nastavené na vibrovanie"</string>
    <string name="sound_settings_summary_silent" msgid="746662794579344761">"Zvonenie je stlmené"</string>
    <string name="sound_settings_example_summary" msgid="8125110691864707925">"Hlasitosť zvonenia a upozornení je na 80 %"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Hlasitosť médií"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Hlasitosť prenášania"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Hlasitosť hovoru"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Hlasitosť budíkov"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Hlasitosť zvonení a upozornení"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Hlasitosť upozornení"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Tón zvonenia telefónu"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Predvolený zvuk upozornenia"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Zvuk z aplikácie"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Predvolený zvuk upozornenia"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Predvolený zvuk budíkov"</string>
    <string name="vibrate_when_ringing_title" msgid="3436203665622843196">"Vibrovať pri hovoroch"</string>
    <string name="keywords_vibrate_for_calls" msgid="1019870409730074899">"Vibrácie"</string>
    <string name="vibrate_when_ringing_option_never_vibrate" msgid="6518980907289156517">"Vypnúť vibrovanie"</string>
    <string name="vibrate_when_ringing_option_always_vibrate" msgid="968652667232075466">"Vždy vibrovať"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Najprv vibrovať, potom stupňovať zvonenie"</string>
    <string name="other_sound_settings" msgid="5468360269346162072">"Iné zvuky"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Zvuky číselnej klávesnice"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Zvuk uzamknutia obrazovky"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Zvuky a vibrácie pri nabíjaní"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Zvuky doku"</string>
    <string name="touch_sounds_title" msgid="2200734041857425078">"Zvuk pri klepnutí"</string>
    <string name="vibrate_on_touch_title" msgid="9105544449810547716">"Vibrácia pri klepnutí"</string>
    <string name="vibrate_on_touch_summary" msgid="664831333409399440">"Hmatová odozva pre klepnutie, klávesnicu a ďalšie akcie"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Reproduktory doku"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Všetky zvukové súbory"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Iba zvukové médiá"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Ticho"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tóny"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibrovanie"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Zvuky pri spustení"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Živý prepis"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Automatické titulkovanie médií"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Žiadne}=1{Bol nastavený 1 plán}few{Boli nastavené # plány}many{# schedules set}other{Bolo nastavených # plánov}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Režim bez vyrušení"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Prijímajte upozornenia iba od dôležitých ľudí a z dôležitých aplikácií"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Obmedzenie vyrušení"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Zapnite režim bez vyrušení"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Budíky a zvuky médií môžu vyrušiť"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Plány"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Odstrániť plány"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Odstrániť"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Upraviť"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Plány"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Plán"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Plán"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Stlmiť telefón v určitý čas"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Nastavenie pravidiel režimu bez vyrušení"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Plán"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Použiť plán"</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">"Povolenie zvukových vyrušení"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokovať vizuálne vyrušenia"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Povoliť vizuálne signály"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Možnosti zobrazenia skrytých upozornení"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Keď je zapnutý režim bez vyrušení"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Upozornenia bez zvuku"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Upozornenia bude vidieť na obrazovke"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Nové upozornenia nebudú vydávať zvuk ani vibrovať."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Upozornenia bez zobrazenia aj zvuku"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Upozornenia nebude vidieť ani počuť"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="4314772315731485747">"Váš telefón nebude zobrazovať nové ani existujúce upozornenia ani na ne nebude upozorňovať vibrovaním či zvukom. Upozorňujeme, že závažné upozornenia týkajúce sa aktivity a stavu telefónu sa budú stále zobrazovať.\n\nKeď vypnete režim bez vyrušení, zmeškané upozornenia zobrazíte potiahnutím prstom nadol z hornej časti obrazovky."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Vlastné"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Povoliť vlastné nastavenie"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Odstrániť vlastné nastavenie"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Upozornenia bez zvuku"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Čiastočne skryté"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Upozornenia bez zobrazenia aj zvuku"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Vlastné obmedzenia"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Keď je obrazovka zapnutá"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Keď je obrazovka vypnutá"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Stlmiť zvuk a vibrácie"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Nezapínať obrazovku"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Neblikať"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Nezobrazovať upozornenia na obrazovke"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Skryť ikony stavového riadka hore na obrazovke"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Skryť bodky upozornení na ikonách aplikácií"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Pri upozorneniach nebudiť"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Skryť z panela upozornení"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nikdy"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Keď je obrazovka vypnutá"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Keď je obrazovka zapnutá"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Zvuk a vibrácie"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Zvuk, vibrácie a niektoré vizuálne signály upozornení"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Zvuk, vibrácie a vizuálne signály upozornení"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="1115914818435434668">"Upozornenia týkajúce sa základnej aktivity telefónu a stavu sa nebudú nikdy skrývať"</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Žiadne"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"ďalšie možnosti"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Pridať"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Zapnúť"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Zapnúť"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Vypnúť"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Režim bez vyrušení je zapnutý do <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Režim bez vyrušení zostane zapnutý, dokým ho nevypnete"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Režim bez vyrušení bol automatický zapnutý v rámci plánu (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Režim bez vyrušení bol automaticky zapnutý aplikáciou (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Režim bez vyrušení je zapnutý pre pravidlá <xliff:g id="RULE_NAMES">%s</xliff:g> s vlastnými nastaveniami."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="2310353944697868606"><annotation id="link">" Zobraziť vlastné nastavenia"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Iba prioritné"</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">"Zapnuté / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Zapnuté"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Vždy sa opýtať"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Dokým funkciu nevypnete"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 hodina}few{# hodiny}many{# hodiny}other{# hodín}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minúta}few{# minúty}many{# minúty}other{# minút}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Vypnuté}=1{Vypnuté / 1 plán sa môže automaticky zapnúť}few{Vypnuté / # plány sa môžu automaticky zapnúť}many{Off / # schedules can turn on automatically}other{Vypnuté / # plánov sa môže automaticky zapnúť}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Čo môže prerušiť režim bez vyrušení"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Ľudia"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Aplikácie"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Budíky a iné vyrušenia"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Plány"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Trvanie rýchlych nastavení"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Keď je zapnutý režim bez vyrušení, zvuky a vibrácie budú vypnuté. Výnimku predstavujú položky, ktoré povolíte vyššie."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Vlastné nastavenia"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Skontrolovať plán"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Dobre"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Upozornenia"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Trvanie"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Správy, udalosti a pripomenutia"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Keď je zapnutý režim bez vyrušení, zvuky správ, pripomenutí a udalostí budú vypnuté. Výnimku predstavujú položky, ktoré povolíte vyššie. Môžete upraviť nastavenia správ a povoliť priateľom, rodine alebo ďalším kontaktom spojiť sa s vami."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Hotovo"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Nastavenia"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Upozornenia bez zobrazenia aj zvuku"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Upozornenia bez zvuku"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Upozornenia sa nebudú zobrazovať ani vydávať zvuky. Povolené sú kontakty s hviezdičkou a opakujúci sa volajúci."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Aktuálne nastavenie)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Zmeniť nastavenia upozornení režimu bez vyrušení?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Zvuky pracovného profilu"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Použiť zvuky osobného profilu"</string>
    <string name="work_use_personal_sounds_summary" msgid="4482832555278975008">"Zvuky sú rovnaké pre pracovný aj osobný profil"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Tón zvonenia pracovného telefónu"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Predvolený zvuk pracovného upozornenia"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Predvolený zvuk pracovného budíka"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Rovnaké ako osobný profil"</string>
    <string name="work_sync_dialog_title" msgid="2359563902332046231">"Nahradiť zvuky?"</string>
    <string name="work_sync_dialog_yes" msgid="9161415252411868574">"Nahradiť"</string>
    <string name="work_sync_dialog_message" msgid="1328692374812258546">"Pre pracovný profil sa použijú zvuky vášho osobného profilu"</string>
    <string name="ringtones_install_custom_sound_title" msgid="3885712267015760638">"Pridať vlastný zvuk?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="5844996763705884979">"Tento súbor sa skopíruje do priečinka <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="26680768777533727">"Tóny zvonenia"</string>
    <string name="other_sound_category_preference_title" msgid="8182757473602586634">"Ďalšie zvuky a vibrácie"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Upozornenia"</string>
    <string name="recent_notifications" msgid="1105631022180160436">"Nedávno odoslané"</string>
    <string name="recent_notifications_see_all_title" msgid="3087299996651692987">"Zobraziť všetko za posledných 7 dní"</string>
    <string name="advanced_section_header" msgid="6003255455888626056">"Rozšírené"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Pracovné upozornenia"</string>
    <string name="smart_notifications_title" msgid="8995288376897952015">"Prispôsobivé upozornenia"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Priorita prispôsobivých upozornení"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Automaticky nastaviť upozornenia s nižšou prioritou ako nenápadné"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Pozícia prispôsobivých upozornení"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Automaticky zoradiť upozornenia podľa relevancie"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Spätná väzba k prispôsobivým upozorneniam"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Uveďte úpravy upozornení a zobrazujte možnosť poskytnúť spätnú väzbu k systému"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Resetovanie dôležitosti upozornenia"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Resetovanie nastavení dôležitosti zmenených používateľom a povolenie priorizácie v asistentovi upozornení"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Navrhované akcie a odpovede"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Automaticky zobrazovať navrhované akcie a odpovede"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Zobrazovanie nedávnych a stlmených upozornení"</string>
    <string name="notification_history" msgid="8663811361243456201">"História upozornení"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Použitie histórie upozornení"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"História upozornení je vypnutá"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Ak si chcete zobraziť nedávne a stlmené upozornenia, zapnite históriu upozornení"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Žiadne nedávne upozornenia"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Tu sa budú zobrazovať nedávne a stlmené upozornenia"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"zobraziť nastavenia upozornení"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"otvoriť upozornenie"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Povoliť stlmenie upozornení"</string>
    <string name="hide_silent_icons_title" msgid="5951392023601167577">"Skrývať ikony nenápadných upozornení"</string>
    <string name="hide_silent_icons_summary" msgid="623763437631637232">"Ikony nenápadných upozornení sa nezobrazujú v stavovom riadku"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Bodka upozornení na ikone apl."</string>
    <string name="notification_people_strip_title" msgid="1185857822541001139">"Zobraziť panel nedávnych konverzácií"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Bubliny"</string>
    <string name="bubbles_feature_education" msgid="4088275802688887634">"Niektoré upozornenia a ďalší obsah sa môžu na obrazovke zobrazovať ako bubliny. Bublinu otvoríte klepnutím. Zatvoríte ju presunutím nadol."</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Bubliny"</string>
    <string name="bubbles_conversation_app_link" msgid="5468779786387915337">"Všetky nastavenia bubliny"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Zobraziť túto konverzáciu v bubline"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Zobrazovať plávajúcu ikonu nad aplikáciami"</string>
    <string name="bubbles_app_toggle_summary" msgid="1574515698567947948">"Povoliť aplikácii <xliff:g id="APP_NAME">%1$s</xliff:g> zobrazovať niektoré upozornenia ako bubliny"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Chcete zapnúť bubliny pre zariadenie?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Zapnutím bublín pre túto aplikáciu aktivujete tiež bubliny pre zariadenie.\n\nOvplyvní to ďalšie aplikácie alebo konverzácie, ktoré môžu zobrazovať bubliny."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Zapnúť"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Zrušiť"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Zapnuté / konverzácie sa môžu zobrazovať ako plávajúce ikony"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Povoliť zobrazovanie bublín aplikáciami"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Niektoré konverzácie sa zobrazia ako plávajúce ikony v hornej časti iných aplikácií"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Všetky konverzácie sa môžu zobrazovať ako bubliny"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Vybrané konverzácie sa môžu zobrazovať ako bubliny"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Nič sa nemôže zobrazovať ako bublina"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Konverzácie"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Všetky konverzácie sa môžu zobrazovať v bublinách okrem"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Vypnúť bubliny pre túto konverzáciu"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Zapnúť bubliny pre túto konverzáciu"</string>
    <string name="swipe_direction_title" msgid="4260320464727178413">"Akcie po potiahnutí"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Doprava: zavrieť, doľava: zobraziť ponuku"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Doľava: zavrieť, doprava: zobraziť ponuku"</string>
    <string name="gentle_notifications_title" msgid="2793492905132530991">"Nenápadné upozornenia"</string>
    <string name="gentle_notifications_also_display" msgid="8617545395880297691">"Zobrazovať aj v "</string>
    <string name="gentle_notifications_display_status" msgid="7410244447768694856">"Stavový riadok"</string>
    <string name="gentle_notifications_display_lock" msgid="1914245082527924144">"Uzamknutá obrazovka"</string>
    <string name="gentle_notifications_education" msgid="5957509621826384362">"Nenápadné upozornenia sú vždy tiché a zobrazujú sa iba v rozbaľovacom paneli"</string>
    <string name="gentle_notifications_display_summary_shade" msgid="7616926954719310445">"Zobrazovať iba v rozbaľovacom paneli"</string>
    <string name="gentle_notifications_display_summary_shade_lock" msgid="3936088046873705625">"Zobrazovať v rozbaľovacom paneli a na uzamknutej obrazovke"</string>
    <string name="gentle_notifications_display_summary_shade_status" msgid="3363137853729359907">"Zobrazovať v rozbaľovacom paneli a stavovom riadku"</string>
    <string name="gentle_notifications_display_summary_shade_status_lock" msgid="2068738866725616212">"Zobrazovať v rozbaľovacom paneli, stavovom riadku a na uzamknutej obrazovke"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Skryť tiché upozornenia v stavovom riadku"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Blikať"</string>
    <string name="lock_screen_notifications_title" msgid="3063951257121435570">"Upozornenia na uzamknutej obrazovke"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Preskakovať uzamknutú obrazovku"</string>
    <string name="lockscreen_bypass_summary" msgid="6688592486830491144">"Po odomk. tvárou priamo prejsť na poslednú použitú obrazovku"</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Uzamknutá obrazovka, preskočiť, obísť"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Keď je prac. profil zamknutý"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Upozornenia na uzamknutej obrazovke"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Zobrazovať konverzácie, predvolené aj tiché"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Skryť tiché konverzácie a upozornenia"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Nezobrazovať žiadne upozornenia"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Citlivé upozornenia"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Zobrazovať po uzamknutí citlivý obsah"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Citlivé upozornenia pracovného profilu"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Zobrazovať po uzamknutí citlivý obsah pracovného profilu"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Zobrazovať kompletné upozornenia"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Zobrazovať citlivý obsah iba po odomknutí"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Nezobrazovať upozornenia"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Ako chcete zobrazovať uzamknutú obrazovku?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Uzamknutá obrazovka"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Zobrazovať všetok obsah pracovných upozornení"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Skryť citlivý pracovný obsah"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Akým spôsobom chcete zobrazovať profilové upozornenia na uzamknutom zariadení?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profilové upozornenia"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Upozornenia"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Upozornenia aplikácií"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Kategória upozornenia"</string>
    <string name="notification_group_title" msgid="7525666535695631538">"Skupina kategórií upozornení"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Správanie"</string>
    <string name="notification_importance_unspecified" msgid="1543165530748339700">"Povoliť zvuk"</string>
    <string name="notification_importance_blocked" msgid="4933285639639899394">"Nikdy nezobrazovať upozornenia"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Konverzácie"</string>
    <string name="conversation_category_title" msgid="6777135786004214149">"Konverzácia"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Sekcia konverzácií"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Povoliť aplikácii používať sekciu konverzácií"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Nejde o konverzáciu"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Odstrániť zo sekcie konverzácií"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Toto je konverzácia"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Pridať do sekcie konverzácií"</string>
    <string name="manage_conversations" msgid="4440289604887824337">"Správa konverzácií"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Žiadne prioritné konverzácie"</string>
    <plurals name="priority_conversation_count" formatted="false" msgid="4229447176780862649">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> prioritné konverzácie</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> priority conversations</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> prioritných konverzácií</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> prioritná konverzácia</item>
    </plurals>
    <string name="important_conversations" msgid="1233893707189659401">"Prioritné konverzácie"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Zobrazovať hore v sekcii konverzácií ako plávajúce bubliny"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Zobrazovať hore v sekcii konverzácií"</string>
    <string name="other_conversations" msgid="551178916855139870">"Konverzácie bez priority"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Konverzácie, ktoré ste zmenili"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Nedávne konverzácie"</string>
    <string name="conversation_settings_clear_recents" msgid="4246342656145488662">"Vymazať všetky nedávne"</string>
    <string name="clear" msgid="5092178335409471100">"Vymazať"</string>
    <string name="important_bubble" msgid="7911698275408390846">"Zobrazovať prioritné konverzácie v bublinách"</string>
    <string name="important_conversation_behavior_summary" msgid="1845064084071107732">"Prioritné konverzácie sa zobrazujú v hornej časti panela upozornení. Môžete tiež nastaviť, aby sa zobrazovali v bubline a prerušili režim bez vyrušení."</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Tu sa budú zobrazovať prioritné a zmenené konverzácie"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Keď označíte konverzáciu ako prioritnú alebo vykonáte v konverzáciách akékoľvek iné zmeny, zobrazia sa tu. \n\nAko zmeniť nastavenia konverzácie: \npotiahnutím z hornej časti obrazovky smerom nadol otvorte panel upozornení a potom pridržte požadovanú konverzáciu."</string>
    <string name="notification_importance_min" msgid="4609688642942787774">"Zobraziť potichu a minimalizovať"</string>
    <string name="notification_importance_low" msgid="7562535765919565273">"Bez zvuku"</string>
    <string name="notification_importance_default" msgid="7483906490369073043">"Vydať zvukový signál"</string>
    <string name="notification_importance_high" msgid="8453789143477210550">"Vydať zvukový signál a vyskočiť na obrazovku"</string>
    <string name="notification_importance_high_silent" msgid="8977232884004607985">"Vyskakovať na obrazovke"</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimalizovať"</string>
    <string name="notification_importance_low_title" msgid="658158049378796947">"Stredná"</string>
    <string name="notification_importance_default_title" msgid="8875198696330289686">"Vysoká"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Vyskakovať na obrazovke"</string>
    <string name="notification_block_title" msgid="7392909527700971673">"Blokovať"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Tiché"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Predvolené"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Povoliť vyrušenia"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Povoliť aplikácii prehrávať zvuk, vibrovať alebo zobrazovať upozornenia na obrazovke"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Priorita"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Nájdete ju v hornej sekcii konverzácie ako plávajúcu bublinu a zobrazuje profilovú fotku na uzamknutej obrazovke"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> nepodporuje väčšinu funkcií konverzácie. Určitú konverzáciu môžete nastaviť ako prioritu a konverzácie sa nebudú zobrazovať ako plávajúce bubliny."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Na rozbaľovacom paneli zbaliť upozornenia do jedného riadka"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Žiadny zvuk ani vibrácie"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Žiadny zvuk ani vibrácie a zobrazuje sa nižšie v sekcii konverzácií"</string>
    <string name="notification_channel_summary_default" msgid="3674057458265438896">"Zvoní či vibruje podľa nastavení telefónu"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Keď je zariadenie odomknuté, zobrazovať upozornenia ako banner v hornej časti obrazovky"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Všetky upozornenia aplikácie <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Všetky upozornenia aplikácie <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="default_notification_assistant" msgid="243718059890346442">"Adaptívne upozornenia"</string>
    <plurals name="notifications_sent_daily" formatted="false" msgid="1479283620504341566">
      <item quantity="few">~<xliff:g id="NUMBER_1">%d</xliff:g> upozornenia denne</item>
      <item quantity="many">~<xliff:g id="NUMBER_1">%d</xliff:g> notifications per day</item>
      <item quantity="other">~<xliff:g id="NUMBER_1">%d</xliff:g> upozornení denne</item>
      <item quantity="one">~<xliff:g id="NUMBER_0">%d</xliff:g> upozornenie denne</item>
    </plurals>
    <plurals name="notifications_sent_weekly" formatted="false" msgid="4913443431857170519">
      <item quantity="few">~<xliff:g id="NUMBER_1">%d</xliff:g> upozornenia týždenne</item>
      <item quantity="many">~<xliff:g id="NUMBER_1">%d</xliff:g> notifications per week</item>
      <item quantity="other">~<xliff:g id="NUMBER_1">%d</xliff:g> upozornení týždenne</item>
      <item quantity="one">~<xliff:g id="NUMBER_0">%d</xliff:g> upozornenie týždenne</item>
    </plurals>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nikdy"</string>
    <string name="manage_notification_access_title" msgid="4714320299084782521">"Prístup k upozorneniam"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Prístup k upozorneniam pracovného profilu je zablokovaný"</string>
    <string name="manage_notification_access_summary_zero" msgid="7528633634628627431">"Aplikácie nesmú čítať upozornenia"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="3703008881487586312">
      <item quantity="few">%d aplikácie dokážu čítať upozornenia</item>
      <item quantity="many">%d aplikácie dokáže čítať upozornenia</item>
      <item quantity="other">%d aplikácií dokáže čítať upozornenia</item>
      <item quantity="one">%d aplikácia dokáže čítať upozornenia</item>
    </plurals>
    <string name="notification_assistant_title" msgid="6983941403582134437">"Adaptívne upozornenia"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Žiadne"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Prístup k upozorneniam si nevyžiadali žiadne nainštalované aplikácie"</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Povoliť prístup k upozorneniam"</string>
    <string name="notification_assistant_security_warning_title" msgid="2972346436050925276">"Povoliť službe <xliff:g id="SERVICE">%1$s</xliff:g> prístup k upozorneniam?"</string>
    <string name="notification_assistant_security_warning_summary" msgid="7362924206925040510">"Aplikácia <xliff:g id="NOTIFICATION_ASSISTANT_NAME">%1$s</xliff:g> bude môcť čítať všetky upozornenia vrátane osobných údajov, ako sú mená kontaktov a texty prijatých správ. Bude môcť tiež zrušiť upozornenia alebo spustiť v nich obsiahnuté tlačidlá spúšťajúce akcie vrátane prijatia telefonického hovoru. \n\nAplikácia tým získa aj možnosť vypnúť alebo zapnúť režim bez vyrušení a meniť súvisiace nastavenia."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Povoliť prístup k upozorneniam pre službu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1658213659262173405">"Aplikácia <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> bude môcť čítať všetky upozornenia vrátane osobných údajov, ako sú mená kontaktov a texty prijatých správ. Bude môcť tiež zrušiť upozornenia alebo spustiť v nich obsiahnuté tlačidlá spúšťajúce akcie vrátane prijatia telefonického hovoru. \n\nAplikácia tým získa aj možnosť vypnúť alebo zapnúť režim bez vyrušení a meniť súvisiace nastavenia."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Ak vypnete prístup k upozorneniam pre aplikáciu <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, môžete tým vypnúť aj prístup k režimu bez vyrušení."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Vypnúť"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Zrušiť"</string>
    <string name="notification_listener_type_title" msgid="2791552789364336733">"Povolené typy upozornení"</string>
    <string name="notif_type_ongoing" msgid="2295338067608686711">"Dôležité prebiehajúce upozornenia"</string>
    <string name="notif_type_conversation" msgid="3014259738224129504">"Upozornenia na konverzáciu"</string>
    <string name="notif_type_alerting" msgid="2300039323822104165">"Varovné upozornenia"</string>
    <string name="notif_type_silent" msgid="2514763073653979199">"Tiché upozornenia"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Pomocné služby VR"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Žiadne nainštalované aplikácie nežiadali, aby boli spúšťané ako pomocné služby VR."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Umožniť službe VR prístup do služby <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> bude možné spustiť pri používaní aplikácií v režime virtuálnej reality."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Keď je zariadenie v režime VR"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Znížiť rozmazanie (odporúčané)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Znížiť blikanie"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Obraz v obraze"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Žiadna z nainštalovaných aplikácií nepodporuje obraz v obraze"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"obraz v obraze"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Obraz v obraze"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Povoliť obraz v obraze"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Povoľte tejto aplikácii vytvoriť okno obrazu v obraze, kým je otvorená alebo keď ju opustíte (napríklad pokračovanie v pozeraní videa). Toto okno sa zobrazuje cez ďalšie aplikácie, ktoré používate."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Prepojené pracovné a osobné aplikácie"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Prepojené"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Neprepojené"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Žiadne pripojené aplikácie"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"viac profilov pripojená aplikácia aplikácie pracovné a osobné"</string>
    <string name="interact_across_profiles_app_detail_title" msgid="7776184211173575648">"Prepojené pracovné a osobné aplikácie"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Prepojené"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Prepojiť tieto aplikácie"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Prepojené aplikácie zdieľajú povolenia a majú vzájomný prístup k svojim údajom."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Pripojte iba tie aplikácie, ktorým dôverujete, že nebudú zdieľať osobné údaje s vaším správcom IT."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Aplikácie môžete kedykoľvek odpojiť v nastaveniach ochrany súkromia zariadenia."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Povolíte pracovnej aplikácii <xliff:g id="NAME">%1$s</xliff:g> prístup k svojim osobným údajom?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Pripojte iba tie aplikácie, ktorým dôverujete, že nebudú zdieľať osobné údaje s vaším správcom IT."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Dáta aplikácií"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Táto aplikácia má prístup k dátam osobnej aplikácie <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Povolenia"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Táto aplikácia môže používať povolenia osobnej aplikácie <xliff:g id="NAME">%1$s</xliff:g>, ako je prístup k polohe, úložisku či kontaktom."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Žiadne aplikácie neprepojené"</string>
    <plurals name="interact_across_profiles_number_of_connected_apps" formatted="false" msgid="6991750455661974772">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> prepojené aplikácie</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> apps connected</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> prepojených aplikácií</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> prepojená aplikácia</item>
    </plurals>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Ak chcete tieto aplikácie pripojiť, nainštalujte aplikáciu <xliff:g id="NAME">%1$s</xliff:g> vo svojom pracovnom profile"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Ak chcete tieto aplikácie pripojiť, nainštalujte aplikáciu <xliff:g id="NAME">%1$s</xliff:g> vo svojom osobnom profile"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Klepnutím získate aplikáciu"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Prístup k režimu bez vyrušení"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Povoliť režim bez vyrušení"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Prístup k režimu bez vyrušení si nevyžiadali žiadne nainštalované aplikácie"</string>
    <string name="loading_notification_apps" msgid="5139471829295287945">"Načítavajú sa aplikácie…"</string>
    <string name="app_notifications_off_desc" msgid="6691342160980435901">"Upozornenia z tejto aplikácie sú v zariadení na vašu žiadosť blokované Androidom"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Táto kategória upozornení je v zariadení na vašu žiadosť blokovaná Androidom"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Táto skupina upozornení je v zariadení na vašu žiadosť blokovaná Androidom"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategórie"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Iné"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="483490958130993160">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategórie</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> kategórie</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategórií</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> kategória</item>
    </plurals>
    <string name="no_channels" msgid="4716199078612071915">"Táto aplikácia ešte neposlala žiadne upozornenia"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Ďalšie nastavenia v aplikácii"</string>
    <string name="notification_screen_summary" msgid="5984915275134654822">"História upozornení, bubliny, nedávno odoslané"</string>
    <string name="app_notification_listing_summary_zero" msgid="2988400013221120744">"Zapnuté pre všetky aplikácie"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="1506127395400503717">
      <item quantity="few">Vypnuté pre <xliff:g id="COUNT_1">%d</xliff:g> aplikácie</item>
      <item quantity="many">Off for <xliff:g id="COUNT_1">%d</xliff:g> apps</item>
      <item quantity="other">Vypnuté pre <xliff:g id="COUNT_1">%d</xliff:g> aplikácií</item>
      <item quantity="one">Vypnuté pre <xliff:g id="COUNT_0">%d</xliff:g> aplikáciu</item>
    </plurals>
    <plurals name="deleted_channels" formatted="false" msgid="5963473421547029532">
      <item quantity="few">Boli odstránené <xliff:g id="COUNT_1">%d</xliff:g> kategórie</item>
      <item quantity="many">Bolo odstránenej <xliff:g id="COUNT_1">%d</xliff:g> kategórie</item>
      <item quantity="other">Bolo odstránených <xliff:g id="COUNT_1">%d</xliff:g> kategórií</item>
      <item quantity="one">Bola odstránená <xliff:g id="COUNT_0">%d</xliff:g> kategória</item>
    </plurals>
    <string name="notification_toggle_on" msgid="1624283327379059003">"Zapnuté"</string>
    <string name="notification_toggle_off" msgid="3295373308338024844">"Vypnuté"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokovať všetko"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Tieto upozornenia nikdy nezobrazovať"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Zobrazovať upozornenia"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Nikdy nezobrazovať upozornenia na paneli ani v periférnych zariadeniach"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Povoliť bodku upozornení"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Zobrazovať bodku upozornení"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Prekonať režim bez vyrušení"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Povoliť týmto upozorneniam vyrušiť ma, keď je zapnutý režim bez vyrušení"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Uzamknutá obrazovka"</string>
    <string name="app_notification_row_banned" msgid="4513523107019706924">"Blokované"</string>
    <string name="app_notification_row_priority" msgid="8100777138078316446">"Priorita"</string>
    <string name="app_notification_row_sensitive" msgid="7374688948587174964">"Citlivé"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Hotovo"</string>
    <string name="app_notification_importance_title" msgid="8293193440040799998">"Dôležitosť"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Blikať"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibrácie"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Zvuk"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Priorita"</string>
    <string name="notification_conversation_add_to_home" msgid="8136269431130231389">"Pridať do domácnosti"</string>
    <string name="zen_mode_rule_delete_button" msgid="7642063606919058862">"Odstrániť"</string>
    <string name="zen_mode_rule_rename_button" msgid="4158377587795511144">"Premenovať"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Názov plánu"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Zadajte názov plánu"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Názov plánu sa už používa"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Pridať ďalšie"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Pridať plán udalosti"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Pridať časový plán"</string>
    <string name="zen_mode_delete_rule" msgid="5419296431989891130">"Odstrániť plán"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Vyberte typ plánu"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Chcete odstrániť pravidlo <xliff:g id="RULE">%1$s</xliff:g>?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Odstrániť"</string>
    <string name="zen_mode_rule_type_unknown" msgid="7819162569994282316">"Neznáme"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Tieto nastavenia momentálne nemôžete zmeniť. Aplikácia (<xliff:g id="APP_NAME">%1$s</xliff:g>) automaticky zapla režim bez vyrušení pomocou vlastného správania."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Tieto nastavenia momentálne nemôžete zmeniť. Aplikácia automaticky zapla režim bez vyrušení pomocou vlastného správania."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Tieto nastavenia momentálne nemôžete zmeniť. Režim bez vyrušení bol automaticky zapnutý pomocou vlastného správania."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Čas"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="6534402316741678208">"Automatické pravidlo zapína režim bez vyrušení v určitých časoch"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Udalosť"</string>
    <string name="zen_event_rule_enabled_toast" msgid="4943723266121388395">"Automatické pravidlo zapína režim bez vyrušení počas určitých udalostí"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Počas udalostí"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="3065013489987409864">"Počas udalostí <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="8395450413356855311">"v ľubovoľnom kalendári"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="7786137431469077008">"V prípade odpovede <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"V ľubovoľnom kalendári"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"V prípade odpovede"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Áno, Možno alebo Bez odpovede"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Áno alebo Možno"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Áno"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Pravidlo sa nenašlo"</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Zapnuté / <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">"Dni"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Žiadne"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="1583884351893245169">"Každý deň"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Budík môže prepísať čas ukončenia"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Plán sa vypne, keď zazvoní budík"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Správanie režimu bez vyrušení"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Použiť predvolené nastavenia"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Vytvorte si vlastné nastavenia tohto plánu"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"V rámci plánu <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="summary_range_verbal_combination" msgid="6022314482293187463">"Od <xliff:g id="START">%1$s</xliff:g> do <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Konverzácie"</string>
    <string name="zen_mode_conversations_section_title" msgid="666809483050936026">"Konverzácie, ktoré môžu vyrušiť"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Všetky konverzácie"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Prioritné konverzácie"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Žiadne"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Žiadne}=1{1 konverzácia}few{# konverzácie}many{# conversations}other{# konverzácií}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Kto môže vyrušiť"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Hovory"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Hovory"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"hovory"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Hovory, ktoré môžu vyrušiť"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Skontrolujte, či je v zariadení zapnuté zvonenie, aby povolené hovory vyzváňali"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"V rámci plánu <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> sú blokované prichádzajúce hovory. Môžete upraviť nastavenia a povoliť priateľom, rodine alebo ďalším kontaktom spojiť sa s vami."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Kontakty s hviezdičkou"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Žiadne}=1{{contact_1}}=2{{contact_1} a {contact_2}}=3{{contact_1}, {contact_2} a {contact_3}}few{{contact_1}, {contact_2} a # ďalšie kontakty}many{{contact_1}, {contact_2}, and # others}other{{contact_1}, {contact_2} a # ďalších kontaktov}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Bez mena)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Správy"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"správy"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Správy"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Správy, ktoré môžu vyrušiť"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Skontrolujte, či je v zariadení zapnuté zvonenie, aby na povolené správy upozorňovalo zvukom"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Prichádzajúce správy sú v rámci plánu <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> blokované. Môžete upraviť nastavenia a povoliť priateľom, rodine alebo ďalším kontaktom spojiť sa s vami."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Dostanete všetky správy"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Dostanete všetky hovory"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Žiadne}=1{1 kontakt}few{# kontakty}many{# contacts}other{# kontaktov}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Ktokoľvek"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontakty"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Kontakty s hviezdičkou"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="8078759939219244001">"Od kontaktov s hviezdičkou a opakujúcich sa volajúcich"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="2276432091940405376">"Od kontaktov a opakujúcich sa volajúcich"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7748352153193832632">"Iba od opakujúcich sa volajúcich"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Žiadne"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Žiadne"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Budíky"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Z časovačov, budíkov, bezpečnostných systémov a ďalších aplikácií"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"budíky"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Budíky"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Zvuky médií"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Zvuky z videí, hier a ďalších médií"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"médiá"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Médiá"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Zvuk pri klepnutí"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Zvuky z klávesnice a iných tlačidiel"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"zvuk pri klepnutí"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Zvuky klepnutia"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Pripomenutia"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Z úloh a pripomenutí"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"pripomenutia"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Pripomenutia"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Udalosti v kalendári"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Z nadchádzajúcich udalostí v kalendári"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"udalosti"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Udalosti"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Povoľte aplikáciám prekonávať nastavenia"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Aplikácie, ktoré môžu vyrušiť"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Vyberte ďalšie aplikácie"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Žiadne vybrané aplikácie"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Žiadne aplikácie nemôžu vyrušiť"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Pridať aplikácie"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Všetky upozornenia"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Niektoré upozornenia"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Vybraní ľudia vás stále môžu kontaktovať, aj keď nepovoľujete aplikáciám vyrušovať"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Žiadne aplikácie nemôžu vyrušiť}=1{{app_1} môže vyrušiť}=2{{app_1} a {app_2} môžu vyrušiť}=3{{app_1}, {app_2} a {app_3} môžu vyrušiť}few{{app_1}, {app_2} a # ďalšie aplikácie môžu vyrušiť}many{{app_1}, {app_2}, and # more can interrupt}other{{app_1}, {app_2} a # ďalších aplikácií môže vyrušiť}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Aplikácie"</string>
    <string name="zen_mode_bypassing_apps_all_summary" msgid="5197566190120503132">"Všetky upozornenia"</string>
    <string name="zen_mode_bypassing_apps_some_summary" msgid="1514572070650411509">"Niektoré upozornenia"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Upozornenia, ktoré môžu vyrušiť"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Povoliť všetky upozornenia"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Žiadne zvuky nemôžu vyrušiť}=1{{sound_category_1} môže vyrušiť}=2{{sound_category_1} a {sound_category_2} môžu vyrušiť}=3{{sound_category_1}, {sound_category_2} a {sound_category_3} môžu vyrušiť}few{{sound_category_1}, {sound_category_2} a # ďalšie zvuky môžu vyrušiť}many{{sound_category_1}, {sound_category_2}, and # more can interrupt}other{{sound_category_1}, {sound_category_2} a # ďalších zvukov môže vyrušiť}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Žiadne zvuky nemôžu vyrušiť"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Nikto nemôže vyrušiť"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Niektorí ľudia môžu vyrušiť"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Všetci ľudia môžu vyrušiť"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Opakované volania"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Povoliť opakované volania"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"kohokoľvek"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontaktov"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"kontaktov s hviezdičkou"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"opakované volania"</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> a <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Ak tá istá osoba zavolá druhýkrát do <xliff:g id="MINUTES">%d</xliff:g> min"</string>
    <string name="zen_mode_behavior_summary_custom" msgid="3126805555852783860">"Vlastné"</string>
    <string name="zen_mode_when" msgid="5710214762051824755">"Zapínať automaticky"</string>
    <string name="zen_mode_when_never" msgid="2537537280091840672">"Nikdy"</string>
    <string name="zen_mode_when_every_night" msgid="9018738747936038166">"Každú noc"</string>
    <string name="zen_mode_when_weeknights" msgid="531342225633264368">"Noci cez týždeň"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Čas začatia"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Čas ukončenia"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> nasledujúci deň"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Zmena na možnosť Iba budíky platná natrvalo"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="1900512966361163390">
      <item quantity="few">Zmena na možnosť Iba budíky platná <xliff:g id="DURATION">%1$d</xliff:g> minúty (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">Zmena na možnosť Iba budíky platná <xliff:g id="DURATION">%1$d</xliff:g> minúty (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Zmena na možnosť Iba budíky platná <xliff:g id="DURATION">%1$d</xliff:g> minút (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Zmena na možnosť Iba budíky platná minútu do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g></item>
    </plurals>
    <plurals name="zen_mode_summary_alarms_only_by_hour" formatted="false" msgid="955991428001659124">
      <item quantity="few">Zmena na možnosť Iba budíky platná <xliff:g id="DURATION">%1$d</xliff:g> hodiny do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="many">Zmena na možnosť Iba budíky platná <xliff:g id="DURATION">%1$d</xliff:g> hodiny do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="other">Zmena na možnosť Iba budíky platná <xliff:g id="DURATION">%1$d</xliff:g> hodín do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="one">Zmena na možnosť Iba budíky platná hodinu do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g></item>
    </plurals>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Zmena na možnosť Iba budíky platná do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Zmena na možnosť Vždy prerušiť"</string>
    <string name="zen_mode_screen_on" msgid="7312758100468915319">"Keď je obrazovka zapnutá"</string>
    <string name="zen_mode_screen_on_summary" msgid="510055058460316698">"Povoliť, aby sa upozornenia stlmené režimom bez vyrušení mohli spúšťať na obrazovke a zobrazovať ikonu v stavovom riadku"</string>
    <string name="zen_mode_screen_off" msgid="7069798697669366075">"Keď je obrazovka vypnutá"</string>
    <string name="zen_mode_screen_off_summary" msgid="4698018253505406152">"Povoliť, aby upozornenia stlmené režimom bez vyrušení mohli zapnúť obrazovku a blikať svetlom"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="1958271859408992636">"Povoliť, aby upozornenia stlmené režimom bez vyrušení mohli zapnúť obrazovku"</string>
    <string name="notification_app_settings_button" msgid="4692549882609342128">"Nastavenia upozornení"</string>
    <string name="suggestion_button_text" msgid="4370673818678692873">"OK"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Zavrieť"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Spätná väzba o zariadení"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Zadajte PIN správcu"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Zapnuté"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Vypnuté"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Pripnutie aplikácie"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Pripnutie aplikácie umožňuje ponechať aktuálnu aplikáciu zobrazenú, než ju odopnete. Pomocou tejto funkcie môžete napríklad dôveryhodnému priateľovi umožniť hrať konkrétnu hru."</string>
    <string name="screen_pinning_description" msgid="7289730998890213708">"Pripnutá aplikácia môže otvárať ďalšie aplikácie a sprístupniť osobné údaje. \n\nAk chcete pripnúť aplikáciu, postupujte takto: 	\n1.	Zapnite pripnutie aplikácie. 	\n2.	Otvorte Prehľad. 	\n3.	Klepnite na ikonu aplikácie v hornej časti obrazovky a potom na Pripnúť."</string>
    <string name="screen_pinning_guest_user_description" msgid="5826264265872938958">"Pripnutá aplikácia môže otvárať ďalšie aplikácie a sprístupniť osobné údaje. \n\nAk chcete zariadenie s niekým zdieľať bezpečne, skúste namiesto toho použiť hosťa. \n\nAk chcete pripnúť aplikáciu, postupujte takto: 	\n1.	Zapnite pripnutie aplikácie. 	\n2.	Otvorte Prehľad. 	\n3.	Klepnite na ikonu aplikácie v hornej časti obrazovky a potom na Pripnúť."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Keď je aplikácia pripnutá: \n\n•		Môžu byť sprístupnené osobné údaje \n		(napríklad kontakty a obsah správ) \n•		Pripnutá aplikácia môže otvárať ďalšie aplikácie \n\nPripnutie aplikácie používajte iba s ľuďmi, ktorým dôverujete."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Pred uvoľnením žiadať bezpečnostný vzor"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Pred odopnutím požiadať o PIN"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Pred uvoľnením požiadať o heslo"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Pri odopnutí zamknúť zariadenie"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Potvrdiť odstránenie SIM karty"</string>
    <string name="confirm_sim_deletion_description" msgid="8937609409607338516">"Pred vymazaním stiahnutej SIM karty overiť, že ste to vy"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Tento pracovný profil spravuje aplikácia:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Spravované aplikáciou <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="869354050717870055">"(Experimentálne)"</string>
    <string name="encryption_interstitial_header" msgid="4418014339568737685">"Bezpečné spustenie"</string>
    <string name="encryption_continue_button" msgid="3591796237625134622">"Pokračovať"</string>
    <string name="encryption_interstitial_message_pin" msgid="1413575143234269985">"Ďalšiu ochranu tohto zariadenia zabezpečíte požadovaním kódu PIN pred spustením. Toto zariadenie nemôže prijímať hovory, správy ani upozornenia (vrátane budíkov), dokým sa nespustí. \n\nPomáha to chrániť dáta v stratených alebo ukradnutých zariadeniach. Vyžadovať kód PIN na spustenie zariadenia?"</string>
    <string name="encryption_interstitial_message_pattern" msgid="726550613252236854">"Ďalšiu ochranu tohto zariadenia zabezpečíte požadovaním vzoru pred spustením. Toto zariadenie nemôže prijímať hovory, správy ani upozornenia (vrátane budíkov), dokým sa nespustí. \n\nPomáha to chrániť dáta v stratených alebo ukradnutých zariadeniach. Vyžadovať vzor na spustenie zariadenia?"</string>
    <string name="encryption_interstitial_message_password" msgid="6051054565294909975">"Ďalšiu ochranu tohto zariadenia zabezpečíte požadovaním hesla pred jeho spustením. Toto zariadenie nemôže prijímať hovory, správy ani upozornenia (vrátane budíkov), dokým sa nespustí. \n\nPomáha to chrániť dáta v stratených alebo ukradnutých zariadeniach. Vyžadovať heslo na spustenie zariadenia?"</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="7152770518093102916">"Okrem odomknutia pomocou odtlačku prsta môžete toto zariadenie ochrániť aj vyžadovaním kódu PIN pred spustením. Zariadenie nemôže prijímať hovory, správy ani upozornenia (vrátane budíkov), dokým sa nespustí.\n\nPomáha to chrániť dáta v stratených alebo ukradnutých zariadeniach. Vyžadovať kód PIN na spustenie zariadenia?"</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="6257856552043740490">"Okrem odomknutia pomocou odtlačku prsta môžete svoje zariadenie ochrániť aj vyžadovaním bezpečnostného vzoru pred spustením. Zariadenie nemôže prijímať hovory, správy ani upozornenia (vrátane budíkov), dokým sa nespustí.\n\nPomáha to chrániť dáta v stratených alebo ukradnutých zariadeniach. Vyžadovať vzor na spustenie zariadenia?"</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="7710804822643612867">"Okrem odomknutia pomocou odtlačku prsta môžete svoje zariadenie ochrániť aj vyžadovaním hesla pred spustením. Zariadenie nemôže prijímať hovory, správy ani upozornenia (vrátane budíkov), dokým sa nespustí.\n\nPomáha to chrániť dáta v stratených alebo ukradnutých zariadeniach. Vyžadovať heslo na spustenie zariadenia?"</string>
    <string name="encryption_interstitial_message_pin_for_face" msgid="8577135499926738241">"Okrem odomknutia pomocou odtlačku prsta môžete toto zariadenie ochrániť aj vyžadovaním kódu PIN pred spustením. Zariadenie nemôže prijímať hovory, správy ani upozornenia (vrátane budíkov), dokým sa nespustí.\n\nPomáha to chrániť dáta v stratených alebo ukradnutých zariadeniach. Vyžadovať kód PIN na spustenie zariadenia?"</string>
    <string name="encryption_interstitial_message_pattern_for_face" msgid="5851725964283239644">"Okrem odomknutia pomocou odtlačku prsta môžete svoje zariadenie ochrániť aj vyžadovaním bezpečnostného vzoru pred spustením. Zariadenie nemôže prijímať hovory, správy ani upozornenia (vrátane budíkov), dokým sa nespustí.\n\nPomáha to chrániť dáta v stratených alebo ukradnutých zariadeniach. Vyžadovať vzor na spustenie zariadenia?"</string>
    <string name="encryption_interstitial_message_password_for_face" msgid="3553329272456428461">"Okrem odomknutia pomocou odtlačku prsta môžete svoje zariadenie ochrániť aj vyžadovaním hesla pred spustením. Zariadenie nemôže prijímať hovory, správy ani upozornenia (vrátane budíkov), dokým sa nespustí.\n\nPomáha to chrániť dáta v stratených alebo ukradnutých zariadeniach. Vyžadovať heslo na spustenie zariadenia?"</string>
    <string name="encryption_interstitial_message_pin_for_biometrics" msgid="4590004045791674901">"Okrem odomknutia pomocou biometrie môžete toto zariadenie ochrániť aj vyžadovaním kódu PIN pred spustením. Toto zariadenie nemôže prijímať hovory, správy ani upozornenia (vrátane budíkov), dokým sa nespustí.\n\nPomáha to chrániť údaje v stratených alebo ukradnutých zariadeniach. Vyžadovať kód PIN na spustenie zariadenia?"</string>
    <string name="encryption_interstitial_message_pattern_for_biometrics" msgid="2697768285995352576">"Okrem odomknutia pomocou biometrie môžete svoje zariadenie ochrániť aj vyžadovaním bezpečnostného vzoru pred spustením. Toto zariadenie nemôže prijímať hovory, správy ani upozornenia (vrátane budíkov), dokým sa nespustí.\n\nPomáha to chrániť údaje v stratených alebo ukradnutých zariadeniach. Vyžadovať vzor na spustenie zariadenia?"</string>
    <string name="encryption_interstitial_message_password_for_biometrics" msgid="1895561539964730123">"Okrem odomknutia pomocou biometrie môžete svoje zariadenie ochrániť aj vyžadovaním hesla pred spustením. Toto zariadenie nemôže prijímať hovory, správy ani upozornenia (vrátane budíkov), dokým sa nespustí.\n\nPomáha to chrániť údaje v stratených alebo ukradnutých zariadeniach. Vyžadovať heslo na spustenie zariadenia?"</string>
    <string name="encryption_interstitial_yes" msgid="1948016725089728181">"Áno"</string>
    <string name="encryption_interstitial_no" msgid="3352331535473118487">"Nie"</string>
    <string name="restricted_true_label" msgid="612852292488747564">"Obmedzené"</string>
    <string name="restricted_false_label" msgid="2837053797913490628">"Aplikácia môže využívať batériu na pozadí"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8974156384205924887">"Vyžadovať kód PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1587587568721873184">"Vyžadovať vzor?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="2701793623210531836">"Vyžadovať heslo?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="4482887117824444481">"Pri zadávaní kódu PIN na spustenie zariadenia ešte nebudú k dispozícii služby dostupnosti, ako napríklad <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="5156321541636018756">"Pri zadávaní vzoru na spustenie zariadenia ešte nebudú k dispozícii služby dostupnosti, ako napríklad <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="1917287751192953034">"Pri zadávaní hesla na spustenie zariadenia ešte nebudú k dispozícii služby dostupnosti, ako napríklad <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="direct_boot_unaware_dialog_message" msgid="5766006106305996844">"Poznámka: Ak reštartujete telefón a máte nastavenú zámku obrazovky, táto aplikácia sa spustí až po odomknutí telefónu"</string>
    <string name="imei_information_title" msgid="8703564992893669514">"Informácie o kóde IMEI"</string>
    <string name="imei_information_summary" msgid="4763358372990258786">"Informácie súvisiace s kódom IMEI"</string>
    <string name="slot_number" msgid="2663789411468530397">"(Slot <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Predvolené otváranie"</string>
    <string name="app_launch_domain_links_title" msgid="6702041169676128550">"Otváranie odkazov"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Otvoriť podporované odkazy"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="3609156836041234957">"Otvárať bez opýtania"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Podporované odkazy"</string>
    <string name="app_launch_other_defaults_title" msgid="3296350563585863885">"Ďalšie predvolené"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"Využité <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">"interné úložisko"</string>
    <string name="storage_type_external" msgid="125078274000280821">"externé úložisko"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"Od <xliff:g id="DATE">%2$s</xliff:g> využité <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Využité úložisko"</string>
    <string name="change" msgid="273206077375322595">"Zmeniť"</string>
    <string name="change_storage" msgid="8773820275624113401">"Zmeniť úložisko"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Upozornenia"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Zapnuté"</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">"Vypnuté"</string>
    <string name="notifications_partly_blocked" msgid="5738239705473445725">"Vypnuté kategórie: <xliff:g id="COUNT_0">%1$d</xliff:g> z <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="notifications_silenced" msgid="2673798575466545098">"Stlmené"</string>
    <string name="notifications_redacted" msgid="8820993927920208612">"Žiadny citlivý obsah na uzamknutej obrazovke"</string>
    <string name="notifications_hidden" msgid="2415415452913806859">"Nezobrazovať na uzamknutej obrazovke"</string>
    <string name="notifications_priority" msgid="9068574646650663837">"Režim bez vyrušení bol prekonaný"</string>
    <string name="notifications_summary_divider" msgid="6877149909390030983">" / "</string>
    <string name="notification_summary_level" msgid="4074326972839105652">"Úroveň %d"</string>
    <string name="notification_summary_channel" msgid="8459033623057872803">"<xliff:g id="CHANNEL_NAME">%1$s</xliff:g> • <xliff:g id="GROUP_NAME">%2$s</xliff:g>"</string>
    <plurals name="notifications_categories_off" formatted="false" msgid="1385401442703692986">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategórie boli vypnuté</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> categories turned off</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategórií bolo vypnutých</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> kategória bola vypnutá</item>
    </plurals>
    <plurals name="permissions_summary" formatted="false" msgid="5015472550875144481">
      <item quantity="few">Boli udelené <xliff:g id="COUNT_1">%d</xliff:g> povolenia</item>
      <item quantity="many">Bolo udeleného <xliff:g id="COUNT_1">%d</xliff:g> povolenia</item>
      <item quantity="other">Bolo udelených <xliff:g id="COUNT_1">%d</xliff:g> povolení</item>
      <item quantity="one">Bolo udelené <xliff:g id="COUNT_0">%d</xliff:g> povolenie</item>
    </plurals>
    <plurals name="runtime_permissions_summary" formatted="false" msgid="2091022049141391855">
      <item quantity="few"><xliff:g id="COUNT_2">%d</xliff:g> udelené povolenia z <xliff:g id="COUNT_3">%d</xliff:g></item>
      <item quantity="many"><xliff:g id="COUNT_2">%d</xliff:g> udeleného povolenia z <xliff:g id="COUNT_3">%d</xliff:g></item>
      <item quantity="other"><xliff:g id="COUNT_2">%d</xliff:g> udelených povolení z <xliff:g id="COUNT_3">%d</xliff:g></item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> udelené povolenie z <xliff:g id="COUNT_1">%d</xliff:g></item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="5888624648943937645">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> ďalšie povolenia</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> ďalšieho povolenia</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> ďalších povolení</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> ďalšie povolenie</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Neboli udelené žiadne povolenia"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Neboli požadované žiadne povolenia"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Ovládajte prístup aplikácií k údajom"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Všetky aplikácie"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Nainštalované aplikácie"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Okamžité aplikácie"</string>
    <string name="filter_notif_all_apps" msgid="2764590815789208306">"Aplikácie: Všetky"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Vypnuté"</string>
    <string name="filter_notif_urgent_channels" msgid="875381675739324318">"Kategórie: Neodkladná dôležitosť"</string>
    <string name="filter_notif_low_channels" msgid="2163005243095264537">"Kategórie: Nízka dôležitosť"</string>
    <string name="filter_notif_blocked_channels" msgid="1131444963543380495">"Kategórie: Vypnuté"</string>
    <string name="filter_notif_dnd_channels" msgid="13445325087914932">"Kategórie: Prepíše režim bez vyrušení"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Rozšírené"</string>
    <string name="configure_apps" msgid="5468359087126598115">"Konfigurácia aplikácií"</string>
    <string name="unknown_app" msgid="2027248925719898714">"Neznáma aplikácia"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Správca povolení"</string>
    <string name="app_permissions_summary" msgid="2709819220672938860">"Aplikácie s povoleniami <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="app_permissions_summary_more" msgid="6247952473615352350">"Aplikácie používajúce povolenia <xliff:g id="APPS">%1$s</xliff:g> a ďalšie"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Zobudiť klepnutím"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Zariadenie prebudíte dvojitým klepnutím na ľubovoľné miesto na obrazovke."</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Otváranie odkazov"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Neotvárať podporované odkazy"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Otvárať <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Otvárať <xliff:g id="DOMAIN">%s</xliff:g> a ďalšie webové adresy"</string>
    <string name="domain_urls_apps_summary_off" msgid="2534980824850890416">"Podporované odkazy neotvára žiadna aplikácia"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="7864816862441985323">
      <item quantity="few">Podporované odkazy otvárajú <xliff:g id="COUNT">%d</xliff:g> aplikácie</item>
      <item quantity="many">Podporované odkazy otvára <xliff:g id="COUNT">%d</xliff:g> aplikácie</item>
      <item quantity="other">Podporované odkazy otvára <xliff:g id="COUNT">%d</xliff:g> aplikácií</item>
      <item quantity="one">Podporované odkazy otvára jedna aplikácia</item>
    </plurals>
    <string name="app_link_open_always" msgid="9167065494930657503">"Povoliť aplikácii otvárať podporované odkazy"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Vždy sa opýtať"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Nepovoliť aplikácii otvárať odkazy"</string>
    <plurals name="app_link_open_always_summary" formatted="false" msgid="1816161439007251694">
      <item quantity="few">Aplikácia žiada o spracovanie <xliff:g id="COUNT_1">%d</xliff:g> odkazov</item>
      <item quantity="many">App claims to handle <xliff:g id="COUNT_1">%d</xliff:g> links</item>
      <item quantity="other">Aplikácia žiada o spracovanie <xliff:g id="COUNT_1">%d</xliff:g> odkazov</item>
      <item quantity="one">Aplikácia žiada o spracovanie <xliff:g id="COUNT_0">%d</xliff:g> odkazu</item>
    </plurals>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Aplikácia žiada o spracovanie nasledujúcich odkazov:"</string>
    <string name="default_apps_title" msgid="6943471331817718664">"Predvolené"</string>
    <string name="default_for_work" msgid="537558180548617528">"Predvolené na prácu"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Asistencia a hlasový vstup"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Digitálny asistent"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Predvolený digitálny asistent"</string>
    <string name="assistant_security_warning_title" msgid="6444187332360938730">"Chcete urobiť z aplikácie <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> pomocnú aplikáciu?"</string>
    <string name="assistant_security_warning" msgid="5623237187748811070">"Asistent bude môcť čítať informácie o aplikáciách používaných v systéme vrátane údajov viditeľných na obrazovke alebo prístupných v aplikáciách."</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Súhlasím"</string>
    <string name="assistant_security_warning_disagree" msgid="1539182108068356410">"Nesúhlasim"</string>
    <string name="choose_voice_input_title" msgid="4855506199101586943">"Výber hlasového vstupu"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Prehliadač"</string>
    <string name="default_browser_title_none" msgid="4691907418284764833">"Žiadny predvolený prehliadač"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Telefónna aplikácia"</string>
    <string name="default_app" msgid="445053777504688596">"(Predvolené)"</string>
    <string name="system_app" msgid="1863291702508355041">"(Systémová)"</string>
    <string name="system_default_app" msgid="2647834628622214931">"(Predvolená systémová)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Ukladací priestor aplikácií"</string>
    <string name="usage_access" msgid="5487993885373893282">"Prístup k dátam o využití"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Povoliť prístup k využitiu"</string>
    <string name="app_usage_preference" msgid="7062447555623339120">"Nastavenia využitia aplikáciami"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Čas používania"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Prístup k využitiu umožňuje aplikácii sledovať, aké ďalšie aplikácie používate, ako často ich používate, a taktiež nastavenia jazyka, operátora a ďalšie podrobnosti."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Pamäť"</string>
    <string name="memory_details_title" msgid="3048107441540417799">"Podrobnosti o pamäti"</string>
    <string name="always_running" msgid="9012705720688200252">"Vždy spustené (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Niekedy spustené (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Výnimočne spustené (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="8721866158069974846">"Maximum"</string>
    <string name="memory_avg_use" msgid="4620476409349875703">"Priemer"</string>
    <string name="memory_max_desc" msgid="6966923521720393526">"Maximum <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="2632995851138152303">"Priemer <xliff:g id="MEMORY">%1$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="process_format" msgid="4239069158701023623">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Optimalizácia batérie"</string>
    <string name="additional_battery_info" msgid="3104208543623068714">"Upozornenia o spotrebe"</string>
    <string name="show_all_apps" msgid="4490719452453223082">"Zobraziť spotrebu zariadenia"</string>
    <string name="hide_extra_apps" msgid="7313907836289865123">"Zobraziť spotrebu aplikácií"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="573433136005336970">
      <item quantity="few"><xliff:g id="NUMBER">%2$d</xliff:g> aplikácie sa správajú nezvyčajne</item>
      <item quantity="many"><xliff:g id="NUMBER">%2$d</xliff:g> apps behaving abnormally</item>
      <item quantity="other"><xliff:g id="NUMBER">%2$d</xliff:g> aplikácií sa správa nezvyčajne</item>
      <item quantity="one"><xliff:g id="APP">%1$s</xliff:g> aplikácia sa správa nezvyčajne</item>
    </plurals>
    <plurals name="power_high_usage_title" formatted="false" msgid="8013115866788425817">
      <item quantity="few">Aplikácie vybíjajúce batériu</item>
      <item quantity="many">Aplikácie vybíjajúce batériu</item>
      <item quantity="other">Aplikácie vybíjajúce batériu</item>
      <item quantity="one"><xliff:g id="APP">%1$s</xliff:g> vybíja batériu</item>
    </plurals>
    <string name="high_power_filter_on" msgid="447849271630431531">"Neoptimalizované"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Neoptimalizované"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimalizuje spotrebu batérie"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Optimalizácia batérie nie je k dispozícii"</string>
    <string name="high_power_desc" msgid="2753076899835765338">"Nepoužívajte optimalizáciu batérie. Môže rýchlejšie vybiť vašu batériu."</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Povoliť aplikácii neustále spustenie na pozadí?"</string>
    <string name="high_power_prompt_body" msgid="6460557929559616041">"Ak povolíte aplikácii <xliff:g id="APP_NAME">%1$s</xliff:g> neustále spustenie na pozadí, môže to skrátiť výdrž batérie. \n\nMôžete to zmeniť neskôr v časti Nastavenia &gt; Aplikácie a upozornenia."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> využitie od posledného úplného dobitia"</string>
    <string name="battery_power_management" msgid="7507188088567087384">"Správa napájania"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Žiadne využitie batérie od posledného úplného dobitia"</string>
    <string name="app_notification_preferences" msgid="2004680717999108725">"Nastavenia aplikácie"</string>
    <string name="system_ui_settings" msgid="936169564323330967">"Zobraziť tuner SystemUI"</string>
    <string name="additional_permissions" msgid="4656871347558988462">"Ďalšie povolenia"</string>
    <string name="additional_permissions_more" msgid="8188145515437525307">"Počet ďalších povolení: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Chcete zdieľať hlásenie chyby?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Správca IT si vyžiadal hlásenie chyby, aby mohol vyriešiť problém na tomto zariadení. Aplikácie a dáta môžu byť zdieľané."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Správca IT si vyžiadal hlásenie chyby, aby mohol vyriešiť problém na tomto zariadení. Aplikácie a dáta môžu byť zdieľané. Môže to dočasne spomaliť vaše zariadenie."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Toto hlásenie chyby sa zdieľa s vaším správcom IT. Ak potrebujete ďalšie podrobnosti, kontaktujte ho."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Zdieľať"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Odmietnuť"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Žiadny prenos údajov"</string>
    <string name="usb_use_charging_only_desc" msgid="1234421230461847336">"Iba nabíjať toto zariadenie"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Nabiť pripojené zariadenie"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Prenos súborov"</string>
    <string name="usb_use_file_transfers_desc" msgid="1020257823387107336">"Prenos súborov do druhého zariadenia"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_photo_transfers_desc" msgid="7490250033610745765">"Prenos fotiek alebo súborov, ak nie je podporované MTP (PTP)"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Tethering cez USB"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="6464135515868405143">"Použiť toto zariadenie ako MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Používať USB na"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Predvolená konfigurácia USB"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Tieto nastavenia sa použijú, keď bude pripojené ďalšie zariadenie a telefón bude odomknutý. Pripájajte sa iba k dôveryhodným zariadeniam."</string>
    <!-- no translation found for usb_power_title (5602112548385798646) -->
    <skip />
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Nastavenia USB"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB ovláda"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Pripojené zariadenie"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Toto zariadenie"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Prepína sa…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Nepodarilo sa prepnúť"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Nabíjanie zariadenia"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Nabíja sa pripojené zariadenie"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Prenos súborov"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Tethering cez USB"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Prenos súborov a poskytovanie napájania"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Tethering cez USB a poskytovanie napájania"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP a poskytovanie napájania"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI a poskytovanie napájania"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Kontrola na pozadí"</string>
    <string name="background_check_title" msgid="225170874283229686">"Úplný prístup na pozadí"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Použiť text z obrazovky"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Povoliť asistenčnej aplikácii prístup k obsahu obrazovky ako k textu"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Použiť snímku obrazovky"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Povoliť asistenčnej aplikácii prístup k snímke obrazovky"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Blikať obrazovkou"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Keď asistenčná aplikácia číta text z obrazovky alebo snímky obrazovky, okraje obrazovky zablikajú"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Asistenčné aplikácie vám pomáhajú na základe informácií zo zobrazenej obrazovky. Niektoré aplikácie podporujú spúšťač aj služby hlasového výstupu, aby vám poskytli integrovanú pomoc."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Priemerné využitie pamäte"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maximálne využitie pamäte"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Využitie pamäte"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Využitie aplikáciami"</string>
    <string name="memory_details" msgid="6133226869214421347">"Podrobnosti"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Za posledné 3 hodiny bolo priemerné využitie pamäte <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Za posledné 3 hodiny nebola využitá žiadna pamäť"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Zoradiť podľa priemerného využitia"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Zoradiť podľa maximálneho využitia"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Výkonnosť"</string>
    <string name="total_memory" msgid="5244174393008910567">"Celková pamäť"</string>
    <string name="average_used" msgid="690235917394070169">"Priemerné využitie (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Voľná pamäť"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Pamäť používaná aplikáciami"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="1355637088533572208">
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikácie použili pamäť za obdobie: <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="many"><xliff:g id="COUNT">%1$d</xliff:g> aplikácie použilo pamäť za obdobie: <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikácií použilo pamäť za obdobie: <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="one">1 aplikácia použila pamäť za obdobie: <xliff:g id="DURATION_0">%2$s</xliff:g></item>
    </plurals>
    <string name="running_frequency" msgid="7260225121706316639">"Frekvencia"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maximálne využitie"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Neboli spotrebované žiadne dáta"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Povoliť aplikácii <xliff:g id="APP">%1$s</xliff:g> prístup k režimu bez vyrušení?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Aplikácia bude môcť vypínať a zapínať režim bez vyrušení a meniť súvisiace nastavenia."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Musí zostať zapnuté, pretože je zapnutý prístup k upozorneniam"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Odvolať prístup k režimu bez vyrušení pre aplikáciu <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Všetky pravidlá režimu bez vyrušení vytvorené touto aplikáciou budú odstránené."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Neoptimalizovať"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimalizovať"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Batéria sa môže vybíjať rýchlejšie. Aplikácie už nebudú mať obmedzené používanie batérie na pozadí."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Odporúčajú sa na predĺženie výdrže batérie"</string>
    <string name="ignore_optimizations_title" msgid="3464172726254542889">"Povoliť aplikácii <xliff:g id="APP">%s</xliff:g> ignorovať optimalizácie batérie?"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Žiadna"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Deaktivovaním prístupu k spotrebe dát pre túto aplikáciu nezabránite správcovi v sledovaní údajov o spotrebe dát pre aplikácie vo vašom pracovnom profile"</string>
    <string name="accessibility_lock_screen_progress" msgid="4597298121698665401">"Použité znaky: <xliff:g id="COUNT_0">%1$d</xliff:g> z <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Zobrazenie cez iné aplikácie"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Zobrazenie cez iné aplikácie"</string>
    <string name="system_alert_window_apps_title" msgid="1537949185175079866">"Aplikácie"</string>
    <string name="system_alert_window_access_title" msgid="3074573819155116817">"Zobrazenie cez iné aplikácie"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Povoliť zobrazenie nad ostatnými aplikáciami"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Umožní tejto aplikácii zobrazovať sa nad inými aplikáciami, ktoré používate. Táto aplikácia bude vidieť, kde klepnete, a môcť zmeniť obsah na obrazovke."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Prístup k všetkým súborom"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Povoľte prístup na správu všetkých súborov"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Povoľte tejto aplikácii čítať, upravovať a odstraňovať všetky súbory v tomto zariadení alebo akýchkoľvek pripojených úložiskách. Po udelení tohto povolenia bude môcť aplikácia používať súbory bez vášho vedomia."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Má prístup k všetkým súborom"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr virtuálna realita prijímač stereo pomocné zariadenie"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Zobrazenie cez iné aplikácie"</string>
    <string name="system_alert_window_summary" msgid="1435856750594492891">"<xliff:g id="COUNT_0">%1$d</xliff:g> z <xliff:g id="COUNT_1">%2$d</xliff:g> aplikácií má povolené zobrazovanie cez iné aplikácie"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Aplikácie s povolením"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Povolené"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Nepovolené"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"inštalácia aplikácie neznáme zdroje"</string>
    <string name="write_settings" msgid="6864794401614425894">"Úpravy nastavení systému"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"zápis a úprava nastavení systému"</string>
    <string name="write_settings_summary" msgid="2085800775513476479">"Úprava nastavení systému je povolená pre <xliff:g id="COUNT_0">%1$d</xliff:g> z <xliff:g id="COUNT_1">%2$d</xliff:g> aplikácií"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Môže inštalovať ďalšie aplikácie"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Môže meniť nastavenia systému"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Môže meniť nastavenia systému"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Úprava nastavení systému"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Povoliť úpravy nastavení systému"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Toto povolenie umožňuje aplikácii meniť nastavenia systému."</string>
    <string name="write_settings_on" msgid="8533286548451191112">"Áno"</string>
    <string name="write_settings_off" msgid="1781103034490679144">"Nie"</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Povoliť z tohto zdroja"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Fotoaparát – dvakrát pokrúťte zápästím"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Otvorte aplikáciu fotoaparátu tak, že dvakrát pokrútite zápästím"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="8264757967127716261">"Fotoaparát dvojitým stlačením vypínača"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="1539147023700755155">"Rýchlo otvárať fotoaparát bez odomknutia obrazovky"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Veľkosť zobrazenia"</string>
    <string name="screen_zoom_short_summary" msgid="2458636490408833800">"Zväčšite alebo zmenšite položky na obrazovke"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"hustota obrazovky, priblíženie obrazovky, veľkosť, zmena veľkosti"</string>
    <string name="screen_zoom_summary" msgid="1362984939045594989">"Zväčšite alebo zmenšite položky na obrazovke. Pozícia niektorých aplikácií na obrazovke sa môže zmeniť."</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Ukážka"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Zmenšiť"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Zväčšiť"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="2896036059049355968">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="4873109337506890558">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="2641317981482545659">"Servus, Peter!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6528272610590915790">"Nezájdeme dnes na kávu?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="6930848361702066106">"Dobre, poznám tu jedno skvelé miesto."</string>
    <string name="screen_zoom_conversation_message_4" msgid="2501043894465807210">"Výborne!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="512353741016062507">"Ut 18:00"</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="472183807915497199">"Ut 18:01"</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="1659313906250856104">"Ut 18:02"</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2046797647382623313">"Ut 18:03"</string>
    <string name="disconnected" msgid="3469373726996129247">"Nepripojené"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Nepripojené"</string>
    <string name="data_usage_summary_format" msgid="6844301859713164522">"<xliff:g id="AMOUNT">%1$s</xliff:g> využitých dát"</string>
    <string name="data_usage_wifi_format" msgid="7644390582649568117">"Spotreba cez Wi-Fi <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <plurals name="notification_summary" formatted="false" msgid="7638388920823212470">
      <item quantity="few">Vypnuté pre <xliff:g id="COUNT">%d</xliff:g> aplikácie</item>
      <item quantity="many">Vypnuté pre <xliff:g id="COUNT">%d</xliff:g> aplikácie</item>
      <item quantity="other">Vypnuté pre <xliff:g id="COUNT">%d</xliff:g> aplikácií</item>
      <item quantity="one">Vypnuté pre 1 aplikáciu</item>
    </plurals>
    <string name="notification_summary_none" msgid="9179312319023988089">"Zapnuté pre všetky aplikácie"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> nainštalovaných aplikácií"</string>
    <string name="apps_summary_example" msgid="6034002063446955592">"24 nainštalovaných aplikácií"</string>
    <string name="storage_summary" msgid="5903562203143572768">"Využité: <xliff:g id="PERCENTAGE">%1$s</xliff:g>, voľné: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="storage_summary_with_sdcard" msgid="2063780050580228868">"Vnútorné úložisko: využité <xliff:g id="PERCENTAGE">%1$s</xliff:g> – voľné <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="display_summary" msgid="5526061030874717172">"Režim spánku sa spustí po <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> nečinnosti"</string>
    <string name="display_dashboard_summary" msgid="5102247404958535634">"Tapeta, režim spánku, veľkosť písma"</string>
    <string name="display_dashboard_summary_with_style" msgid="2792175367835485163">"Štýly, tapety, časový limit obrazovky, veľkosť písma"</string>
    <string name="display_dashboard_nowallpaper_summary" msgid="6198590533661927162">"Režim spánku, veľkosť písma"</string>
    <string name="display_summary_example" msgid="4275121979039344438">"Režim spánku sa spustí po 10 minútach nečinnosti"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Využíva sa v priemere <xliff:g id="USED_MEMORY">%1$s</xliff:g> z celkovej pamäte <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="8473589474976307510">"Prihlásený používateľ <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="5513009140568552693">"<xliff:g id="APP_NAME">%1$s</xliff:g> je predvolená aplikácia"</string>
    <string name="backup_disabled" msgid="4503062265560959320">"Zálohovanie je zakázané"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Aktualizované na Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"K dispozícii je aktualizácia"</string>
    <string name="disabled_by_policy_title" msgid="8296938784202750494">"Akcia nie je povolená"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Hlasitosť sa nedá zmeniť"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="2776004460663768982">"Hovory sú zakázané"</string>
    <string name="disabled_by_policy_title_sms" msgid="6309460145439706922">"Správy SMS sú zakázané"</string>
    <string name="disabled_by_policy_title_camera" msgid="8567781468959299078">"Použitie fotoaparátu je zakázané"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6137746705692573992">"Snímky obrazovky sú zakázané"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Táto aplikácia sa nedá otvoriť"</string>
    <string name="default_admin_support_msg" msgid="8338570262037182531">"Ak máte nejaké otázky, obráťte sa na svojho správcu IT"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Ďalšie podrobnosti"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Správca môže sledovať a spravovať aplikácie a údaje priradené k vášmu pracovnému profilu vrátane nastavení, povolení, firemného prístupu, aktivity siete a informácií o polohe zariadenia."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Správca môže sledovať a spravovať aplikácie a údaje priradené k tomuto používateľovi vrátane nastavení, povolení, firemného prístupu, aktivity siete a informácií o polohe zariadenia."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Správca môže sledovať a spravovať aplikácie a údaje priradené k tomuto zariadeniu vrátane nastavení, povolení, firemného prístupu, aktivity siete a informácií o polohe zariadenia."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Vypnúť"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Zapnúť"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Zobraziť"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Skryť"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Hotspot je aktívny"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Režim v lietadle je zapnutý"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Siete nie sú k dispozícii"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Je zapnutý režim bez vyrušení"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Telefón má vypnutý zvuk"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"S výnimkami"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Šetrič batérie je zapnutý"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funkcie sú obmedzené"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobilné dáta sú vypnuté"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet je k dispozícii iba cez Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Šetrič dát"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funkcie sú obmedzené"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Pracovný profil je vypnutý"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Pre aplikácie a upozornenia"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Zapnúť zvuk"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Zvonenie bolo vypnuté"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Pri hovoroch a upozorneniach"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Iba vibrácie"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Pri hovoroch a upozorneniach"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Nastavenie harmonogramu Nočného režimu"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Každý večer automaticky tónovať obrazovku"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Nočný režim je zapnutý"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Obrazovka má oranžový tón"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Odfarbenie"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Zobraziť iba sivo"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Zbaliť"</string>
    <string name="suggestions_title_v2" msgid="421003737901460147">"Navrhnuté pre vás"</string>
    <string name="suggestions_title" msgid="61841299295602686">"Návrhy"</string>
    <string name="suggestions_summary" msgid="1709710458908440469">"+<xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="240124526378997009">"+ďalšie (<xliff:g id="ID_1">%1$d</xliff:g>)"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="5023679825210836444">
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> návrhy</item>
      <item quantity="many"><xliff:g id="COUNT">%1$d</xliff:g> návrhu</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> návrhov</item>
      <item quantity="one">1 návrh</item>
    </plurals>
    <plurals name="suggestions_collapsed_summary" formatted="false" msgid="3789011332018516832">
      <item quantity="few">+ <xliff:g id="COUNT">%1$d</xliff:g> návrhy</item>
      <item quantity="many">+ <xliff:g id="COUNT">%1$d</xliff:g> návrhu</item>
      <item quantity="other">+ <xliff:g id="COUNT">%1$d</xliff:g> návrhov</item>
      <item quantity="one">+ 1 návrh</item>
    </plurals>
    <string name="suggestion_remove" msgid="6753986344585367776">"Odstrániť"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Studená teplota farby"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Používať studenšie farby obrazovky"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Ak chcete použiť zmenu farby, vypnite obrazovku"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Laserový snímač fotoaparátu"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatické aktualizácie systému"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Použiť aktualizácie po reštartovaní zariadenia"</string>
    <string name="usage" msgid="287782903846013936">"Spotreba"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Spotreba mobilných dát"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Spotreba dát aplikáciami"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Spotreba dát cez Wi‑Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Spotreba dát mimo operátora"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Spotreba dát prostredníctvom ethernetu"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi‑Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> mobilných dát"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"Dáta Wi‑Fi: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"Ethernetové dáta: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Dátové upozornenie a limit"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Cyklus spotreby mobilných dát"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Dátové upozornenie: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Dátový limit: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Dátové upozornenie: <xliff:g id="ID_1">^1</xliff:g> / dátový limit: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="billing_cycle_fragment_summary" msgid="6346655500491631357">"Každý mesiac v <xliff:g id="ID_1">%1$s</xliff:g>. deň"</string>
    <string name="network_restrictions" msgid="8385824604048229846">"Obmedzenia siete"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="3875128958788008975">
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> obmedzenia</item>
      <item quantity="many"><xliff:g id="COUNT">%1$d</xliff:g> obmedzenia</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> obmedzení</item>
      <item quantity="one">1 obmedzenie</item>
    </plurals>
    <string name="operator_warning" msgid="5672761970087591211">"Účtovanie dát operátorom sa môže líšiť od účtovania na zariadení"</string>
    <string name="non_carrier_data_usage_warning" msgid="7361998122602474430">"Vylučuje dáta spotrebované sieťami operátora"</string>
    <string name="data_used_template" msgid="8229342096562327646">"Spotreba <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Nastaviť dátové upozornenie"</string>
    <string name="data_warning" msgid="2925054658166062884">"Dátové upozornenie"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Dátové upozornenie a dátový limit meria zariadenie. Údaje sa môžu líšiť od údajov operátora."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Nastaviť dátový limit"</string>
    <string name="data_limit" msgid="8731731657513652363">"Dátový limit"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_2">%2$s</xliff:g> spotreba <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Konfigurovať"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Iné aplikácie zahrnuté v prehľade spotreby dát"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="3316296488378947221">
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikácie majú povolené používať neobmedzené dáta, keď je zapnutý šetrič dát</item>
      <item quantity="many"><xliff:g id="COUNT">%1$d</xliff:g> aplikácie má povolené používať neobmedzené dáta, keď je zapnutý šetrič dáta</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikácií má povolené používať neobmedzené dáta, keď je zapnutý šetrič dát</item>
      <item quantity="one">1 aplikácia má povolené používať neobmedzené dáta, keď je zapnutý šetrič dát</item>
    </plurals>
    <string name="data_usage_title" msgid="4039024073687469094">"Primárne dáta"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Dáta Wi‑Fi"</string>
    <string name="data_used" msgid="7770571947591789895">"Spotreba <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Využité: <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Prekročený limit <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Zostáva: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Graf zobrazuje spotrebu dát od <xliff:g id="START_DATE">%1$s</xliff:g> do <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Pre tento rozsah dátumov neexistujú žiadne údaje."</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="661792524671718753">
      <item quantity="few">Zostávajú %d dni</item>
      <item quantity="many">Zostáva %d dňa</item>
      <item quantity="other">Zostáva %d dní</item>
      <item quantity="one">Zostáva %d deň</item>
    </plurals>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Žiadny zostávajúci čas"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Zostáva menej ako 1 deň"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Aktualizované pred <xliff:g id="ID_2">^2</xliff:g> – <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Aktualizované pred <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Práve aktualizované – <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Práve aktualizované"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Zobraziť tarifu"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Zobraziť podrobnosti"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Šetrič dát"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Neobmedzené dáta"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Dáta na pozadí sú vypnuté"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Zapnutý"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Vypnutý"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Používať šetrič dát"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Neobmedzené využitie dát"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Povoliť neobmedzený prístup k dátam, keď je zapnutý šetrič dát"</string>
    <string name="home_app" msgid="6056850504746902747">"Vstupná aplikácia"</string>
    <string name="no_default_home" msgid="3588073707316139318">"Žiadna predvolená domovská aplikácia"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="4098653943835666086">"Bezpečné spustenie"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="311325321794497404">"Na spustenie zariadenia sa bude vyžadovať bezpečnostný vzor. Keď je zariadenie vypnuté, nemôže prijímať hovory, správy, upozornenia ani používať budíky"</string>
    <string name="lockpattern_settings_require_pin_before_startup_summary" msgid="1881271630312222251">"Na spustenie zariadenia sa bude vyžadovať kód PIN. Keď je zariadenie vypnuté, nemôže prijímať hovory, správy, upozornenia ani používať budíky"</string>
    <string name="lockpattern_settings_require_password_before_startup_summary" msgid="8651761245246411947">"Na spustenie zariadenia sa bude vyžadovať heslo. Keď je zariadenie vypnuté, nemôže prijímať hovory, správy, upozornenia ani používať budíky."</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Pridať ďalší odtlačok prsta"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Odomknutie pomocou iného odtlačku"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Zapnuté"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Zapne sa na úrovni <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Vypnuté"</string>
    <string name="battery_saver_button_turn_on" msgid="2206239048232352476">"Zapnúť"</string>
    <string name="battery_saver_button_turn_off" msgid="6371072408072481484">"Vypnúť"</string>
    <string name="not_battery_optimizing" msgid="8361294470943376258">"Nepoužíva sa optimalizácia batérie"</string>
    <string name="lockscreen_remote_input" msgid="6030274311185811503">"Pri uzamknutom zariadení zakázať v upozorneniach písať odpovede či iný text"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Predvolená kontrola pravopisu"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Výber kontroly pravopisu"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Používať kontrolu pravopisu"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Nie je vybraté"</string>
    <string name="notification_log_no_title" msgid="2343315128609978203">"(žiadny)"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"balík"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"kľúč"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"skupina"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(súhrn)"</string>
    <string name="notification_log_details_visibility" msgid="6811292866832243357">"viditeľnosť"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"verejná verzia"</string>
    <string name="notification_log_details_priority" msgid="4772047133062255513">"priorita"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"dôležitosť"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"vysvetlenie"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"môže zobraziť odznak"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"intencia"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"odstrániť intenciu"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"intencia celej obrazovky"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"akcie"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"nadpis"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"vzdialené vstupy"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"vlastné zobrazenie"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"Bonusové položky"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"veľkosť parcely"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"aktivované upozornenie"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanál"</string>
    <string name="notification_log_details_none" msgid="1090852853755089991">"žiadne"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Chýba objekt hodnotenia."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Objekt hodnotenia neobsahuje tento kľúč."</string>
    <string name="theme_customization_device_default" msgid="7641813022590999286">"Predvolené nastavenie zariadenia"</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Výrez obrazovky"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"výrez obrazovky, výrez"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Predvolené nastavenie zariadenia"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Nepodarilo sa prekryť"</string>
    <string name="special_access" msgid="1767980727423395147">"Špeciálny prístup aplikácií"</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <item quantity="few">Neobmedzené dáta môžu používať <xliff:g id="COUNT">%d</xliff:g> aplikácie</item>
      <item quantity="many">Neobmedzené dáta môže používať <xliff:g id="COUNT">%d</xliff:g> aplikácie</item>
      <item quantity="other">Neobmedzené dáta môže používať <xliff:g id="COUNT">%d</xliff:g> aplikácií</item>
      <item quantity="one">Neobmedzené dáta môže používať 1 aplikácia</item>
    </plurals>
    <string name="special_access_more" msgid="132919514147475846">"Zobraziť viac"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="3783325656948378111">"Naozaj chcete vymazať údaje používateľa a konvertovať na šifrovanie súborov?"</string>
    <string name="button_confirm_convert_fbe" msgid="339648921918438106">"Vymazať a konvertovať"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Resetovať obmedzovanie frekvencie žiadostí v službe ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Obmedzovanie frekvencie žiadostí v službe ShortcutManager bolo resetované"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Ovládajte informácie na uzamknutej obrazovke"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Zobrazujte si obsah upozornení alebo ho skryte"</string>
    <string name="page_tab_title_summary" msgid="7188875610123234454">"Všetko"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Tipy a podpora"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Minimálna šírka"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Prístup k prémiovým správam SMS si nevyžiadali žiadne nainštalované aplikácie"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Za prémiové správy SMS sa môžu účtovať poplatky, ktoré sa naúčtujú na faktúru operátora. Ak aktivujete toto povolenie pre aplikáciu, budete môcť pomocou nej posielať prémiové správy SMS."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Prístup k prémiovým správam SMS"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Vypnuté"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Pripojené k zariadeniu <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Pripojené k viacerým zariadeniam"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Ukážka používateľského rozhrania systému"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tmavý motív"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Dočasne vypnuté šetričom batérie"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Dočasne zapnuté šetričom batérie"</string>
    <string name="dark_ui_settings_dark_summary" msgid="1214821092462388494">"Na tmavý motív sa prepnú aj podporované aplikácie"</string>
    <string name="dark_ui_settings_dialog_acknowledge" msgid="250437497729953965">"Dobre"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Vyskúšať tmavý motív"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Pomáha predĺžiť výdrž batérie"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Dlaždice rýchlych nastavení pre vývojárov"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Vypnutie časového limitu autorizácií adb"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Vypnite automatické odvolanie autorizácií adb systémov, ktoré neboli pripojené počas predvoleného (7 dní) alebo používateľom nastaveného (minimálne 1 deň) časového obdobia."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Trasovanie Winscope"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Senzory sú vypnuté"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Nastavenia pracovného profilu"</string>
    <string name="managed_profile_contact_search_title" msgid="7685402733942182110">"Vyhľadávanie kontaktov"</string>
    <string name="managed_profile_contact_search_summary" msgid="2771343453017731940">"Povoliť vašej organizácii hľadať kontakty na identifikáciu volajúcich a kontaktov"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kalendár s viacerými profilmi"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Zobrazovať pracovné udalosti v osobnom kalendári"</string>
    <plurals name="hours" formatted="false" msgid="1853396353451635458">
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> hodiny</item>
      <item quantity="many"><xliff:g id="NUMBER">%s</xliff:g> hodiny</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> hodín</item>
      <item quantity="one">1 hodina</item>
    </plurals>
    <plurals name="minutes" formatted="false" msgid="6244503272924425418">
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> minúty</item>
      <item quantity="many"><xliff:g id="NUMBER">%s</xliff:g> minúty</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> minút</item>
      <item quantity="one">1 minúta</item>
    </plurals>
    <plurals name="seconds" formatted="false" msgid="4237020272336995370">
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> sekundy</item>
      <item quantity="many"><xliff:g id="NUMBER">%s</xliff:g> sekundy</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> sekúnd</item>
      <item quantity="one">1 sekunda</item>
    </plurals>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Spravovať úložisko"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Správca úložiska odstraňuje zálohované fotky a videá z vášho zariadenia, čím pomáha uvoľniť miesto v úložisku."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Odstrániť fotky a videá"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Správca úložiska"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Používať správcu priestoru"</string>
    <string name="deletion_helper_automatic_title" msgid="597196990024769472">"Automaticky"</string>
    <string name="deletion_helper_manual_title" msgid="1068812971600327101">"Ručne"</string>
    <string name="deletion_helper_preference_title" msgid="6364023246849161274">"Uvoľniť miesto"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gestá"</string>
    <string name="gesture_preference_summary" product="default" msgid="7941981260703379398">"Rýchle gestá na ovládanie telefónu"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4031666250963488007">"Rýchle gestá na ovládanie tabletu"</string>
    <string name="gesture_preference_summary" product="device" msgid="3520072325356373349">"Rýchle gestá na ovládanie zariadenia"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Rýchlo spustiť fotoaparát"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Fotoaparát rýchlo otvoríte dvojitým stlačením vypínača. Funguje to na každej obrazovke."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="4299496243418753571">"Rýchle spustenie fotoaparátu"</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Otočiť fotoaparát na selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="8178844037382604158">"Rýchlejšie fotenie snímok selfie"</string>
    <string name="system_navigation_title" msgid="1698862900901417194">"Navigácia v systéme"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigácia dvoma tlačidlami"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Medzi aplikáciami prepnete potiahnutím nahor po tlačidle plochy. Opätovným potiahnutím nahor zobrazíte všetky aplikácie. Vrátite sa klepnutím na tlačidlo Späť."</string>
    <string name="swipe_up_to_switch_apps_suggestion_title" msgid="5754081720589900007">"Vyskúšajte nové tlačidlo plochy"</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="8885866570559435110">"Zapnite nové gesto na prepínanie aplikácií"</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Bezpečnosť a stav tiesne"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigácia gestami"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"Na plochu prejdete tak, že potiahnete nahor z dolnej časti obrazovky. Aplikácie prepnete tak, že potiahnete zdola nahor, podržíte a pustíte. Späť sa vrátite tak, že potiahnete od ľavého alebo pravého okraja obrazovky."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navigácia troma tlačidlami"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Na návrat späť, zobrazenie plochy a prepínanie aplikácií slúžia tlačidlá dole na obrazovke."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navigácia v systéme, navigácia dvoma tlačidlami, navigácia troma tlačidlami, navigácia gestami, potiahnutie"</string>
    <string name="gesture_not_supported_dialog_message" msgid="5316512246119347889">"Predvolená vstupná aplikácia <xliff:g id="DEFAULT_HOME_APP">%s</xliff:g> túto funkciu nepodporuje"</string>
    <string name="gesture_not_supported_positive_button" msgid="7909969459977021893">"Prepnúť predvolenú vstupnú aplikáciu"</string>
    <string name="information_label" msgid="6939310810756569298">"Informácie"</string>
    <string name="low_label" msgid="6525629096999711220">"Nízka"</string>
    <string name="high_label" msgid="357503396626018487">"Vysoká"</string>
    <string name="left_edge" msgid="1513576842959071849">"Ľavý okraj"</string>
    <string name="right_edge" msgid="1505309103265829121">"Pravý okraj"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Vyššia citlivosť môže kolidovať s gestami aplikácie pri okrajoch obrazovky."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Citlivosť prechádzania späť"</string>
    <string name="gesture_settings_activity_title" msgid="6047431928567911330">"Nastavenia gest"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigácia gestami, citlivosť prechádzania späť, gesto späť"</string>
    <string name="ambient_display_title" product="default" msgid="5885136049497127396">"Kontrola telefónu dvojitým klepnutím"</string>
    <string name="ambient_display_title" product="tablet" msgid="205744440641466921">"Tablet skontrolujete dvojitým klepnutím"</string>
    <string name="ambient_display_title" product="device" msgid="4164103424628824786">"Zariadenie skontrolujete dvojitým klepnutím"</string>
    <string name="swipe_bottom_to_notifications_title" msgid="7631744948948666524">"Upozornenia prejd. prstom"</string>
    <string name="swipe_bottom_to_notifications_summary" msgid="8073261995155440308">"Upozornenia zobrazíte potiahnutím pri dolnom okraji obrazovky smerom nadol"</string>
    <string name="one_handed_title" msgid="1741600445540072513">"Režim jednej ruky"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Použiť režim jednej ruky"</string>
    <string name="one_handed_app_taps_to_exit" msgid="1496702498286387879">"Ukončiť pri prepínaní aplikácií"</string>
    <string name="one_handed_timeout_title" msgid="8851767822595789976">"Časový limit"</string>
    <string name="one_handed_timeout_short" msgid="304069319841702995">"4 sekundy"</string>
    <string name="one_handed_timeout_medium" msgid="6723411319911799018">"8 sekúnd"</string>
    <string name="one_handed_timeout_long" msgid="6537332654662635890">"12 sekúnd"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"dosiahnuteľnosť"</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Ak chcete zistiť čas, skontrolovať upozornenia a získať ďalšie informácie, klepnite dvakrát na obrazovku."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="4418310591912877548">"Kontrola telefónu zdvihnutím"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="8055486872070888377">"Tablet skontrolujete tak, že ho zodvihnete"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="8980156994848721455">"Zariadenie skontrolujete tak, že ho zodvihnete"</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Prebudiť obrazovku"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="1087355013674109242">"Ak chcete zistiť čas, skontrolovať upozornenia a získať ďalšie informácie, zdvihnite telefón."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="2589556997034530529">"Ak chcete zistiť čas, skontrolovať upozornenia a získať ďalšie informácie, zdvihnite tablet."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="1916011370011115627">"Ak chcete zistiť čas, skontrolovať upozornenia a získať ďalšie informácie, zdvihnite zariadenie."</string>
    <string name="ambient_display_tap_screen_title" product="default" msgid="2811332293938467179">"Kontrola telefónu klepnutím"</string>
    <string name="ambient_display_tap_screen_title" product="tablet" msgid="6461531447715370632">"Klepnutím skontrolujete tablet"</string>
    <string name="ambient_display_tap_screen_title" product="device" msgid="4423803387551153840">"Klepnutím skontrolujete zariadenie"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Ak chcete zistiť čas, skontrolovať upozornenia a získať ďalšie informácie, klepnite na obrazovku."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Tiesňové SOS"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7494629420708117232">"Používať tiesňové SOS"</string>
    <string name="emergency_gesture_entrypoint_summary" msgid="4730874229911208834">"Spravované aplikáciou <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="emergency_gesture_screen_summary" msgid="458991229689082120">"Akcie nižšie spustíte tak, že aspoň päťkrát rýchlo stlačíte vypínač"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Prehrať upozornenie na odpočítavanie"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="9215504009890604179">"Pred zavolaním pomoci prehrať hlasitý zvuk"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Volanie o pomoc"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Číslo, na ktoré môžete volať o pomoc"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Zmeníte klepnutím."</string>
    <string name="emergency_gesture_number_override_notes" msgid="7270300987756837957">"Keď zadáte linku, ktorá nie je tiesňová:\n • vaše zariadenie musí byť odomknuté, aby ste mohli použiť tiesňovú funkciu SOS;\n • váš hovor nemusí byť prijatý."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Upozornenia odtlačkom prsta"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Potiahnutie prstom"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="286662791588779673">"Upozornenia zobrazíte potiahnutím nadol po senzore odtlačkov prstov na zadnej strane telefónu."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet" msgid="8642092907817554454">"Upozornenia zobrazíte potiahnutím nadol po senzore odtlačkov prstov na zadnej strane tabletu."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="device" msgid="3888927017311372398">"Upozornenia zobrazíte potiahnutím nadol po senzore odtlačkov prstov na zadnej strane zariadenia."</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Rýchle zobrazenie upozornení"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Zapnuté"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Vypnuté"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Bootloader je už odomknutý"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="8045017109714463041">"Najprv sa pripojte k internetu"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Pripojte sa k internetu alebo kontaktujte svojho operátora"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Nedostupné na zariadeniach s blokovaním operátora"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Reštartujte zariadenie a aktivujte tak funkciu ochrany zariadenia."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Uvoľnené celkove: <xliff:g id="SIZE">%1$s</xliff:g>\n\nNaposledy spustené: <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Okamžité aplikácie"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Otvárajte odkazy v aplikáciách, aj keď nie sú nainštalované"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Okamžité aplikácie"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Nastavenia okamžitých aplikácií"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Nainštalované aplikácie"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Vaše úložisko odteraz riadi správca úložiska"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Účty používateľa <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="configure_section_header" msgid="3126887329521705210">"Konfigurácia"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Automaticky synchronizovať dáta aplikácií"</string>
    <string name="auto_sync_personal_account_title" msgid="3544275021920818595">"Automaticky synchronizovať osobné dáta"</string>
    <string name="auto_sync_work_account_title" msgid="6060310415978781885">"Automaticky synchronizovať pracovné dáta"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Umožniť aplikáciám automatické obnovovanie údajov"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Synchronizácia účtu"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Synchronizácia je zapnutá pre <xliff:g id="ID_1">%1$d</xliff:g> z <xliff:g id="ID_2">%2$d</xliff:g> položiek"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Synchronizácia je zapnutá pre všetky položky"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Synchronizácia je vypnutá pre všetky položky"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Informácie o spravovanom zariadení"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Zmeny a nastavenia spravované vašou organizáciou"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Zmeny a nastavenia spravované organizáciou <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Vaša organizácia môže zmeniť nastavenia a nainštalovať softvér na vašom zariadení, aby vám poskytla prístup k pracovným dátam.\n\nĎalšie informácie získate od správcu organizácie."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Typy informácií, ktoré vidí vaša organizácia"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Zmeny, ktoré vykonal správca vašej organizácie"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Váš prístup k tomuto zariadeniu"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Dáta priradené k vášmu pracovnému účtu, ako napríklad pošta a kalendár"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Zoznam aplikácií na zariadení"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Strávený čas a objem využitých dát v každej aplikácii"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Posledný denník sieťovej premávky"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Posledné hlásenie chyby"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Posledný denník zabezpečenia"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Žiadne"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Nainštalované aplikácie"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Počet aplikácií je odhadnutý. Nemusí zahrnovať aplikácie nainštalované mimo Obchodu Play."</string>
    <plurals name="enterprise_privacy_number_packages_lower_bound" formatted="false" msgid="5403847001419529018">
      <item quantity="few">Minimálne <xliff:g id="COUNT_1">%d</xliff:g> aplikácie</item>
      <item quantity="many">Minimálne <xliff:g id="COUNT_1">%d</xliff:g> aplikácie</item>
      <item quantity="other">Minimálne <xliff:g id="COUNT_1">%d</xliff:g> aplikácií</item>
      <item quantity="one">Minimálne <xliff:g id="COUNT_0">%d</xliff:g> aplikácia</item>
    </plurals>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Miestne povolenia"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Povolenia mikrofónu"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Povolenia fotoaparátu"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Predvolené aplikácie"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="8568544906431825430">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> aplikácie</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> aplikácie</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aplikácií</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> aplikácia</item>
    </plurals>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Predvolená klávesnica"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Nastavené na možnosť <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Trvalé pripojenie k sieti VPN je zapnuté"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Trvalé pripojenie k sieti VPN je zapnuté vo vašom osobnom profile"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Trvalé pripojenie k sieti VPN je zapnuté vo vašom pracovnom profile"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Bol nastavený globálny proxy server protokolu HTTP"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Dôveryhodné poverenia"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Dôveryhodné poverenia vo vašom osobnom profile"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Dôveryhodné poverenia vo vašom pracovnom profile"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="6459725295322004179">
      <item quantity="few">Minimálne <xliff:g id="COUNT_1">%d</xliff:g> certifikáty CA</item>
      <item quantity="many">Minimálne <xliff:g id="COUNT_1">%d</xliff:g> certifikátu CA</item>
      <item quantity="other">Minimálne <xliff:g id="COUNT_1">%d</xliff:g> certifikátov CA</item>
      <item quantity="one">Minimálne <xliff:g id="COUNT_0">%d</xliff:g> certifikát CA</item>
    </plurals>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Správca môže uzamknúť zariadenie a obnoviť heslo"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Správca môže zo zariadenia odstrániť všetky údaje"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Počet nesprávnych zadaní hesla pred odstránením všetkých dát zariadenia"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Počet nesprávnych zadaní hesla pred odstránením dát pracovného profilu"</string>
    <plurals name="enterprise_privacy_number_failed_password_wipe" formatted="false" msgid="8811973918944217791">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> pokusy</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> pokusu</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> pokusov</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> pokus</item>
    </plurals>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Toto zariadenie spravuje vaša organizácia."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Toto zariadenie spravuje organizácia <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">"Ďalšie informácie"</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="8112432929729136399">
      <item quantity="few">Aplikácie na fotografovanie</item>
      <item quantity="many">Aplikácie na fotografovanie</item>
      <item quantity="other">Aplikácie na fotografovanie</item>
      <item quantity="one">Aplikácia na fotografovanie</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Aplikácia Kalendár"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Aplikácia Kontakty"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="8338194872609410234">
      <item quantity="few">E-mailové aplikácie</item>
      <item quantity="many">E-mailové aplikácie</item>
      <item quantity="other">E-mailové aplikácie</item>
      <item quantity="one">E-mailová aplikácia</item>
    </plurals>
    <string name="default_map_app_title" msgid="7569231732944853320">"Aplikácia Mapa"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="4222188821845826493">
      <item quantity="few">Aplikácie na telefonovanie</item>
      <item quantity="many">Aplikácie na telefonovanie</item>
      <item quantity="other">Aplikácie na telefonovanie</item>
      <item quantity="one">Aplikácia na telefonovanie</item>
    </plurals>
    <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_photos_videos" msgid="6926197783745481869">"Fotky a videá"</string>
    <string name="storage_music_audio" msgid="1185624135490182822">"Hudba a zvuk"</string>
    <string name="storage_games" msgid="1176568610086802469">"Hry"</string>
    <string name="storage_other_apps" msgid="5902520888043081176">"Ďalšie aplikácie"</string>
    <string name="storage_files" msgid="7968460921272772299">"Súbory"</string>
    <string name="storage_size_large_alternate" msgid="7555149858858591495">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">^2</xliff:g>"</font></small>""</string>
    <string name="storage_volume_total" msgid="7102720999351050601">"Využité z <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_percent_full" msgid="7211888326013020857">"využité"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Vymazať aplikáciu"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Chcete túto okamžitú aplikáciu odstrániť?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Otvoriť"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Hry"</string>
    <string name="audio_files_title" msgid="5981409295669041303">"Zvukové súbory"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Využité miesto"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(odinštalované pre používateľa <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(vypnuté pre používateľa <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Služba automatického dopĺňania"</string>
    <string name="autofill_keywords" msgid="6260653325195017912">"automatické, dopĺňanie, automatické dopĺňanie"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Skontrolujte, či ide o dôveryhodnú aplikáciu&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Automatické dopĺňanie Google&gt;%1$s&lt;/xliff:g&gt; určuje na základe obsahu obrazovky, čo je možné automaticky vyplniť."</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Automatické dopĺňanie"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Úroveň zaznamenávania"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Maximálny počet žiadostí na reláciu"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Max. viditeľných množín dát"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Resetovať na predvolené hodnoty"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Možnosti automatického dopĺňania pre vývojárov boli obnovené"</string>
    <string name="location_category" msgid="3496759112306219062">"Miesto"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Indikátor umiestnenia stavového riadka"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Zobrazí všetky miesta vrátane siete a pripojenia"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Vynútiť úplné meranie GNSS"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Sledovať všetky konštelácie a frekvencie GNSS bez cyklického vypínania a zapínania"</string>
    <string name="device_theme" msgid="5027604586494772471">"Motív zariadenia"</string>
    <string name="default_theme" msgid="4815428567082263639">"Predvolený"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Názov siete"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Zobrazovať názov siete v stavovom riadku"</string>
    <string name="storage_manager_indicator" msgid="6187509172735927297">"Správca úložiska: <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="2705959642617709265">"Vypnutý"</string>
    <string name="storage_manager_indicator_on" msgid="8380330763647785309">"Zapnutý"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Okamžitá aplikácia"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Vypnúť správcu úložiska?"</string>
    <string name="storage_movies_tv" msgid="7897612625450668593">"Filmové a televízne aplikácie"</string>
    <string name="carrier_provisioning" msgid="7217868336140325816">"Informácie o poskytovaní služieb operátorom"</string>
    <string name="trigger_carrier_provisioning" msgid="3288805742683538597">"Spustiť poskytovanie služieb operátorom"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Aktualizovať režim bez vyrušení"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pozastavte upozornenia, aby ste sa mohli sústrediť"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funkcia nie je k dispozícii"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Táto funkcia bola vypnutá, pretože spomaľuje telefón"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Vždy zobrazovať dialógové okno zlyhania"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Zobraziť dialógové okno pri každom zlyhaní aplikácie"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Vybrať aplikáciu podporujúcu ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Nie je nastavená žiadna aplikácia podporujúca ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Aplikácia podporujúca ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Predvoľby grafického ovládača"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Zmeňte nastavenia grafického ovládača"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Keď je k dispozícii viacero grafických ovládačov, môžete použiť aktualizovaný grafický ovládač pre aplikácie nainštalované v zariadení."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Povoliť pre všetky aplikácie"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Vybrať grafický ovládač"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Predvolené"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Ovládač hry"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Ovládač vývojára"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Grafický ovládač systému"</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="platform_compat_dashboard_title" msgid="1323980546791790236">"Zmeny v kompatibilite aplikácie"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Prepínač zmien kompatibility aplikácie"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Predvolené aktivované zmeny"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Predvolené deaktivované zmeny"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"Žiadne aplikácie"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Zmeny kompatibility môžete upraviť iba v prípade laditeľných aplikácií. Nainštalujte si laditeľnú aplikáciu a skúste to znova."</string>
    <string name="unsupported_setting_summary" product="default" msgid="1085229417771470172">"Nastavenie nie je v tomto telefóne podporované"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="7402414129786489664">"Nastavenie nie je v tomto tablete podporované"</string>
    <string name="unsupported_setting_summary" product="device" msgid="3422953459122926833">"Nastavenie nie je v tomto zariadení podporované"</string>
    <string name="disabled_for_user_setting_summary" msgid="9096036019081828639">"Aktuálny používateľ toto nastavenie nemôže zmeniť"</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Závisí od iného nastavenia"</string>
    <string name="unknown_unavailability_setting_summary" msgid="9060213910510360231">"Nastavenie nie je k dispozícii"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Účet"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Názov zariadenia"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Ovládanie Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Povoliť aplikácii ovládať Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Povoliť tejto aplikácii zapínať a vypínať Wi-Fi, hľadať siete Wi-Fi a pripájať sa k nim, pridávať a odstraňovať siete alebo vytvárať miestny hotspot"</string>
    <string name="media_output_title" msgid="8283629315159510680">"Prehrať média v zariadení"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Prehrať <xliff:g id="LABEL">%s</xliff:g> v zariadení"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Toto zariadenie"</string>
    <string name="media_output_summary" product="default" msgid="4760338801715262899">"Telefón"</string>
    <string name="media_output_summary" product="tablet" msgid="5138101426462250247">"Tablet"</string>
    <string name="media_output_summary" product="device" msgid="3598300438694764381">"Zariadenie"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Počas hovorov nie je k dispozícii"</string>
    <string name="media_output_summary_unavailable" msgid="2695058965888813093">"Nedostupné"</string>
    <string name="media_output_group_panel_title" msgid="3086245179062913037">"Pridanie výstupov"</string>
    <string name="media_output_group" msgid="7918231774595274396">"Skupina"</string>
    <string name="media_output_group_panel_single_device_summary" msgid="5027884071572180516">"1 vybrané zariadenie"</string>
    <string name="media_output_group_panel_multiple_devices_summary" msgid="4838305763151455248">"Počet vybraných zariadení: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="media_output_switching" msgid="7488216595474868546">"Prepína sa…"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Prijať hovor v zariadení"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Tento názov prístupového bodu sa nedá zmeniť."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="1525940496459255289">"Predĺženie výdrže batérie tabletu"</string>
    <string name="battery_suggestion_title" product="device" msgid="2280773774080720377">"Predĺženie výdrže batérie zariadenia"</string>
    <string name="battery_suggestion_title" product="default" msgid="4811554469047272537">"Predĺženie výdrže batérie telefónu"</string>
    <string name="battery_suggestion_summary" msgid="8186720080540016197"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Vypnutie zvonenia"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Stlačením vypínača a tlač. zvýšenia hlas. zapnete možnosť:"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Skratka na vypnutie zvonenia"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibrovať"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Vypnúť zvuk"</string>
    <string name="prevent_ringing_option_none" msgid="7776676007180834163">"Nerobiť nič"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibrovať"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Vypnúť zvuk"</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Podrobnosti siete"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"Názov zariadenia uvidia aplikácie v telefóne. Keď sa pripojíte k zariadeniam s rozhraním Bluetooth alebo sieti Wi‑Fi, prípadne ak nastavíte hotspot Wi‑Fi, môžu ho uvidieť aj ostatní ľudia."</string>
    <string name="devices_title" msgid="649715719278562515">"Zariadenia"</string>
    <string name="homepage_all_settings" msgid="1877827279189801035">"Všetky nastavenia"</string>
    <string name="homepage_personal_settings" msgid="8312279476519359656">"Návrhy"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Vybrať sieť"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Odpojené"</string>
    <string name="network_connected" msgid="7637745547242487795">"Pripojené"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Pripája sa…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Nepodarilo sa pripojiť"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Nebola nájdená žiadna sieť."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Nepodarilo sa nájsť siete. Skúste to znova."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(zakázané)"</string>
    <string name="no_sim_card" msgid="1497407489810953863">"Žiadna SIM karta"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Žiadna SIM karta"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Žiadne"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Na pripojenie sa vyžaduje SIM karta"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Na pripojenie sa vyžaduje SIM karta <xliff:g id="WIRELESS_CARRIER">%s</xliff:g>"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Preferovaný režim siete: preferované WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Preferovaný režim siete: iba GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Preferovaný režim siete: iba WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Preferovaný režim siete: GSM / WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Preferovaný režim siete: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Preferovaný režim siete: CDMA / EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Preferovaný režim siete: iba CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Preferovaný režim siete: iba EVDO"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Preferovaný režim siete: CDMA / EvDo / GSM / WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Preferovaný režim siete: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Preferovaný režim siete: GSM / WCDMA / LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Preferovaný režim siete: CDMA + LTE / EvDo"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Preferovaný režim siete: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Preferovaný režim siete: globálny"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Preferovaný režim siete: LTE / WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Uprednostňovaný režim siete: LTE / GSM / UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Preferovaný režim siete: LTE / CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Preferovaný režim siete: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Preferovaný režim siete: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Preferovaný režim siete: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Preferovaný režim siete: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Preferovaný režim siete: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Preferovaný režim siete: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Preferovaný režim siete: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Preferovaný režim siete: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Preferovaný režim siete: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Preferovaný režim siete: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Preferovaný režim siete: iba NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Preferovaný režim siete: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Preferovaný režim siete: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Preferovaný režim siete NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Preferovaný režim siete: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Preferovaný režim siete: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Preferovaný režim siete: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Preferovaný režim siete: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Preferovaný režim siete: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Preferovaný režim siete: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Preferovaný režim siete: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_recommended" msgid="4665525658003183348">" (odporúčané)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (odporúčané)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (odporúčané)"</string>
    <string name="label_available" msgid="5305726869955838606">"Dostupné siete"</string>
    <string name="load_networks_progress" msgid="4717874401621250401">"Hľadá sa…"</string>
    <string name="register_on_network" msgid="2169662800750709709">"Prebieha registrácia v sieti <xliff:g id="NETWORK">%s</xliff:g>…"</string>
    <string name="not_allowed" msgid="5756935665192962915">"Vaša SIM karta nepovoľuje pripojenie k tejto sieti."</string>
    <string name="connect_later" msgid="2330538069949281352">"V tejto chvíli sa nedá pripojiť k sieti. Skúste to neskôr."</string>
    <string name="registration_done" msgid="1750434215698850123">"Prihlásenie k sieti prebehlo úspešne."</string>
    <string name="select_automatically" msgid="2419752566747259155">"Vybrať sieť automaticky"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Nastavenia operátora"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Nastaviť dátovú službu"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobilné dáta"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Prístup k dátam pomocou mobilnej siete"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefón sa automaticky prepne na tohto operátora, keď bude v dosahu"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="3309106501029928951">"Nie je k dispozícii žiadna SIM karta"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Predvolená služba pre hovory"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Predvolená služba pre SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Vždy sa opýtať"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Pridať sieť"</string>
    <plurals name="mobile_network_summary_count" formatted="false" msgid="5173633860800230925">
      <item quantity="few"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM karty</item>
      <item quantity="many"><xliff:g id="COUNT_1">%1$d</xliff:g> SIMs</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM kariet</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> SIM karta</item>
    </plurals>
    <string name="default_for_calls" msgid="2788950217176988034">"Predvolená pre hovory"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Predvolená pre SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Predvolená pre hovory a SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Predvolená pre mobilné dáta"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobilné dáta sú aktívne"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobilné dáta sú vypnuté"</string>
    <string name="subscription_available" msgid="2659722770210403365">"K dispozícii"</string>
    <string name="mobile_network_in_range" msgid="3528320750936028369">"V dosahu"</string>
    <string name="mobile_network_not_in_range" msgid="5680896182395366584">"Mimo dosahu"</string>
    <string name="mobile_network_list_add_more" msgid="4478586073355236604">"Pridať ďalšie"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktívne / SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Neaktívne / SIM"</string>
    <string name="mobile_network_active_esim" msgid="4673190244386572318">"Aktívne / stiahnutá SIM karta"</string>
    <string name="mobile_network_inactive_esim" msgid="2901035056727849007">"Neaktívne / stiahnutá SIM karta"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Názov a farba SIM karty"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Názov"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Farba (používajú kompatibilné aplikácie)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Uložiť"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Používať SIM kartu"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Vypnuté"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Ak chcete túto SIM kartu deaktivovať, odstráňte ju"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Klepnutím aktivujete operátora <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_esim_swap_confirm_title" msgid="2762744961192218789">"Chcete prepnúť na operátora <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="mobile_network_esim_swap_confirm_body" msgid="8168680839542031781">"V jednej chvíli môže byť aktívna iba jedna stiahnutá SIM karta.\n\nPrepnutím na operátora <xliff:g id="CARRIER1">%1$s</xliff:g> nezrušíte službu operátora <xliff:g id="CARRIER2">%2$s</xliff:g>."</string>
    <string name="mobile_network_esim_swap_confirm_ok" msgid="8695772737522378095">"Prepnúť na <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Vymazať SIM kartu"</string>
    <string name="mobile_network_erase_sim_error_dialog_title" msgid="6680959559589234726">"SIM karta sa nedá vymazať"</string>
    <string name="mobile_network_erase_sim_error_dialog_body" msgid="6401922869095572710">"SIM karta sa nedá vymazať, pretože došlo k chybe.\n\nReštartujte zariadenie a skúste to znova."</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Preferovaný typ siete"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Zmeniť prevádzkový režim siete"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Preferovaný typ siete"</string>
    <string name="carrier_settings_euicc" msgid="1541279297111378907">"Operátor"</string>
    <string name="carrier_settings_version" msgid="4738147451583140935">"Verzia nastavení"</string>
    <string name="call_category" msgid="641461844504128789">"Volanie"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Videohovory prostredníctvom operátora"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Výber systému"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Zmeniť režim roamingu CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Výber systému"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Sieť"</string>
    <string name="network_select_title" msgid="4532395144000206685">"Sieť"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Odber CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Prepnúť medzi RUIM/SIM a NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"odber"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automatická registrácia…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Chcete povoliť dátový roaming?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Informácie o cenách získate od svojho poskytovateľa siete."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Spotreba dát aplikáciami"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Neplatný režim siete <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignorovať."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Názvy prístupových bodov"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Nie je k dispozícii pri pripojení k operátorovi <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Zobraziť viac"</string>
    <string name="see_less" msgid="2642392725363552793">"Zobraziť menej"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Chcete zapnúť operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Chcete zapnúť SIM kartu?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Chcete prepnúť na operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Chcete používať SIM kartu?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"V jednej chvíli môže byť aktívna iba jedna stiahnutá SIM karta.\n\nPrepnutím na operátora <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> nezrušíte službu operátora <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="1396320209544698027">"V jednej chvíli môže byť aktívna iba jedna stiahnutá SIM karta.\n\nPrepnutím na operátora <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> nezrušíte službu operátora <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"V jednej chvíli môže byť aktívna iba jedna stiahnutá SIM karta.\n\nPoužitím inej možnosti nezrušíte službu operátora <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Prepnúť na operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Pripája sa k sieti…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="8341013572582875574">"Prepína sa na operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Operátora sa nepodarilo prepnúť"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Operátora sa nepodarilo prepnúť, pretože sa vyskytla chyba."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Chcete vypnúť operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Chcete vypnúť SIM kartu?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Vypína sa SIM karta<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Operátora sa nepodarilo deaktivovať"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Vyskytol sa problém a operátora sa nepodarilo deaktivovať."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Chcete používať dve SIM karty?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"V tomto zariadení môžu byť naraz aktívne dve SIM karty. Ak chcete ďalej používať len jednu, klepnite na Nie, ďakujem."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Chcete reštartovať zariadenie?"</string>
    <string name="sim_action_restart_text" msgid="8019300474703571013">"Začnite reštartovaním zariadenia. Potom môžete pridať ďalšiu SIM kartu."</string>
    <string name="sim_action_continue" msgid="1688813133152389943">"Pokračovať"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Reštartovať"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Nie, vďaka"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Prepnúť"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"SIM kartu sa nepodarilo aktivovať"</string>
    <string name="dsds_activation_failure_body_msg1" msgid="6303921196869256391">"Vyberte SIM kartu a znova ju vložte. Ak bude problém pretrvávať, reštartujte zariadenie."</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Skúste SIM kartu znova zapnúť. Ak bude problém pretrvávať, reštartujte zariadenie."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Aktivácia siete"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"Operátor <xliff:g id="CARRIER_NAME">%1$s</xliff:g> je aktívny"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Klepnutím aktualizujete nastavenia SIM karty"</string>
    <string name="sim_card_label" msgid="5632157635124050923">"SIM karta"</string>
    <string name="erase_sim_dialog_title" msgid="881253002169177016">"Chcete vymazať túto stiahnutú SIM kartu?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Vymazaním tejto SIM karty odstránite službu operátora <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> z tohto zariadenia.\n\nSlužba operátora <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> sa nezruší."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Vymazať"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Odstraňuje sa SIM karta…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"SIM karta sa nedá vymazať"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"SIM karta sa nedá vymazať, pretože došlo k chybe.\n\nReštartujte zariadenie a skúste to znova."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Pripojenie k zariadeniu"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"<xliff:g id="APPNAME">%1$s</xliff:g> chce použiť dočasnú sieť Wi‑Fi na pripojenie k vášmu zariadeniu"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Nenašli sa žiadne zariadenia. Skontrolujte, či sú zariadenia zapnuté a dostupné na pripojenie."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Skúsiť znova"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Vyskytol sa problém. Aplikácia zrušila žiadosť o výber zariadenia."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Pripojenie je úspešné"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Nepodarilo sa pripojiť"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Zobraziť všetko"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Hľadá sa zariadenie…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Pripája sa k zariadeniu…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Ľavé"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Pravé"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Puzdro"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Panel s nastaveniami"</string>
    <string name="internet_connectivity_panel_title" msgid="2044237561024730108">"Internetové pripojenie"</string>
    <string name="volume_connectivity_panel_title" msgid="8772438444782726321">"Hlasitosť"</string>
    <string name="mobile_data_ap_mode_disabled" msgid="6067959496888990983">"Nedostupné v režime v lietadle"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Vynútiť režim pracovnej plochy"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Vynútenie experimentálneho režimu pracovnej plochy na sekundárnych obrazovkách"</string>
    <!-- no translation found for enable_non_resizable_multi_window (6832903754625404477) -->
    <skip />
    <!-- no translation found for enable_non_resizable_multi_window_summary (3275763753261901999) -->
    <skip />
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Presadiť tmavý režim"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Presadí, aby bol tmavý režim vždy zapnutý"</string>
    <string name="enable_blurs_on_windows_title" msgid="4218144213800778872">"Aktivovať rozmazania"</string>
    <string name="enable_blurs_on_windows_summary" msgid="8962906921531490386">"Aktivuje rozmazanie okna na úrovni skladania. Vyžaduje sa reštartovanie zariadenia."</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Ochrana súkromia"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Povolenia, aktivita účtu, osobné údaje"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Odstrániť"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Ponechať"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Chcete odstrániť tento návrh?"</string>
    <string name="contextual_card_removed_message" msgid="5755438207494260867">"Návrh bol odstránený"</string>
    <string name="contextual_card_undo_dismissal_text" msgid="5200381837316691406">"Späť"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Málo miesta. Využité: <xliff:g id="PERCENTAGE">%1$s</xliff:g>, voľné: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Odoslať spätnú väzbu"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Chcete nám v súvislosti s týmto návrhom poskytnúť spätnú väzbu?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"Položka <xliff:g id="COPY_CONTENT">%1$s</xliff:g> bola skopírovaná do schránky."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="permission_bar_chart_empty_text" msgid="4856719891991325077">"Povolenia nepoužili žiadne aplikácie"</string>
    <string name="permission_bar_chart_title" msgid="2493212904955611441">"Používanie povolení za posledných 24 hodín"</string>
    <string name="permission_bar_chart_details" msgid="5816698018592357088">"Zobraziť všetko v hlavnom paneli"</string>
    <plurals name="permission_bar_chart_label" formatted="false" msgid="4853396794340896078">
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> aplikácie</item>
      <item quantity="many"><xliff:g id="NUMBER">%s</xliff:g> apps</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> aplikácií</item>
      <item quantity="one">1 aplikácia</item>
    </plurals>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Využitie dostupnosti"</string>
    <plurals name="accessibility_usage_summary" formatted="false" msgid="6910643986958263005">
      <item quantity="few">Do vášho zariadenia majú prístup <xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikácie</item>
      <item quantity="many"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> apps have full access to your device</item>
      <item quantity="other">Do vášho zariadenia má prístup <xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikácií</item>
      <item quantity="one">Do vášho zariadenia má prístup 1 aplikácia</item>
    </plurals>
    <string name="media_output_panel_title" msgid="5920946795078065159">"Prepnutie výstupu"</string>
    <string name="media_output_panel_summary_of_playing_device" msgid="6998758947764222915">"Momentálne sa prehráva v zariadení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="media_output_disconnected_status" msgid="5567111639832431865">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> (odpojené)"</string>
    <string name="media_output_switch_error_text" msgid="603563475910236831">"Nedá sa prepnúť. Zopakujte klepnutím."</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Dôležité informácie"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"POKRAČOVAŤ"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NIE, ĎAKUJEM"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Poloha"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="2799241640320172899">"Na účely poskytovania tejto služby môže váš poskytovateľ zhromažďovať údaje o vašej polohe.\n\nPrečítajte si pravidlá ochrany súkromia vášho poskytovateľa služieb."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Môžete prísť o prístup k zostávajúcemu času či dátam. Pred odstránením sa poraďte so svojím operátorom."</string>
    <string name="keywords_content_capture" msgid="7802155522681936956">"snímanie obsahu, obsah aplikácie"</string>
    <string name="content_capture" msgid="868372905432812238">"Obsah aplikácie"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Umožnite aplikáciam odosielať obsah do Androidu"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Zachytávať zálohy údajov systému"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Zachytávajú sa zálohy údajov systému"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Nepodarilo sa zachytiť zálohy údajov systému"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Automaticky zachytávať zálohy údajov systému"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Automaticky zachytávať zálohy údajov systému Android, keď využíva príliš veľa pamäte"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Odpojiť"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Tiesňové volania"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Váš operátor nepodporuje tiesňové volania pomocou volania cez Wi‑Fi.\nZariadenie sa na tiesňové volanie automaticky prepne na mobilnú sieť.\nTiesňové volania sú možné iba v oblastiach s mobilným signálom."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Volajte cez Wi‑Fi a zlepšite tak kvalitu"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Záložné volanie"</string>
    <string name="backup_calling_setting_summary" msgid="451295393447465830">"Ak nie je <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> k dispozícii, volajte a prijímajte hovory <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g> pomocou mobilnej dátovej SIM karty."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"záložné volanie"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Prichádzajúca správa MMS"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Správu MMS sa nepodarilo odoslať"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Klepnutím povolíte správy MMS cez operátora <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> pri vypnutých mobilných dátach"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problém s kombináciou SIM kariet"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Použitie operátora <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> môže obmedziť funkcie. Ďalšie informácie zobrazíte klepnutím."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Kombinácia SIM kariet"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informácie o pracovných pravidlách"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Nastavenia spravované vaším správcom IT"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"Grafický procesor"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Obsluha hlásení chýb"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Určuje, ktorá aplikácia vo vašom zariadení obsluhuje odkaz na hlásenie chýb."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Osobné"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Práca"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Predvolené systémom"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Táto voľba už nie je platná. Skúste to znova."</string>
    <string name="device_controls_sentence" msgid="4887752349920801907">"Ovládanie zariadení"</string>
    <string name="quick_controls_lower" msgid="6675573610027367819">"ovládanie zariadení"</string>
    <string name="cards_passes_sentence" msgid="1866311782387946944">"Karty a lístky"</string>
    <string name="cards_passes_lower" msgid="2429722007109957877">"karty a lístky"</string>
    <string name="power_menu_setting_name" msgid="7843519296976254765">"Ponuka vypínača"</string>
    <string name="power_menu_setting_title" msgid="7716546106215378956">"Ponuka vypínača"</string>
    <string name="power_menu_cards_passes" msgid="1707852019651773645">"Zobraziť karty a lístky"</string>
    <string name="power_menu_device_controls" msgid="5114816270328063924">"Zobraziť ovládanie zariadení"</string>
    <string name="power_menu_cards_passes_device_controls" msgid="8645794247280620106">"Zobraziť karty, lístky a ovládanie zariadení"</string>
    <string name="power_menu_lock_screen_category" msgid="1478249026305417128">"Uzamknutá obrazovka"</string>
    <string name="power_menu_none" msgid="4620640577918731270">"Nezobrazovať žiadny obsah"</string>
    <string name="power_menu_privacy" msgid="7900052501075197854">"Citlivý obsah"</string>
    <string name="power_menu_privacy_show" msgid="2112741022037054383">"Zobraziť karty a ovládacie prvky pri uzamknutí"</string>
    <string name="power_menu_privacy_show_controls" msgid="8294874046577167797">"Zobrazovať po uzamknutí ovládacie prvky"</string>
    <string name="power_menu_privacy_show_cards" msgid="8937303188629541026">"Zobrazovať karty počas uzamknutia"</string>
    <string name="power_menu_privacy_hide" msgid="1617102911157977095">"Skryť karty a ovládacie prvky pri uzamknutí"</string>
    <string name="power_menu_privacy_not_secure" msgid="6247119934128206924">"Pred použitím treba nastaviť zámku obrazovky"</string>
    <string name="device_controls_setting_toggle" msgid="8972005569207737469">"Zobraziť ovládanie zariadení"</string>
    <string name="cards_passes_setting_toggle" msgid="3380984848045396695">"Zobraziť karty a lístky"</string>
    <string name="device_controls_setting_subtitle" msgid="4388544861427973600">"Ovládače pripojených zariadení si zobrazíte pridržaním vypínača"</string>
    <string name="cards_passes_setting_subtitle" msgid="4427459738229697469">"Ak si chcete zobraziť svoje spôsoby platby alebo cestovné a palubné lístky, pridržte vypínač."</string>
    <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="media_output_panel_stop_casting_button" msgid="6094875883164119035">"Zastaviť prenos"</string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Chcete vypnúť VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Bude tiež vypnuté pripojenie 5G.\nPočas hlasového hovoru nebudete môcť používať internet a niektoré aplikácie nemusia fungovať."</string>
    <string name="no_5g_in_dsds_text" product="default" msgid="772747677303920132">"Keď použijete dve SIM karty, tento telefón bude obmedzený na 4G. "<annotation id="url">"Ďalšie informácie"</annotation></string>
    <string name="no_5g_in_dsds_text" product="tablet" msgid="4757328474425714624">"Keď použijete dve SIM karty, tento tablet bude obmedzený na 4G. "<annotation id="url">"Ďalšie informácie"</annotation></string>
    <string name="no_5g_in_dsds_text" product="device" msgid="6983783505032683314">"Keď použijete dve SIM karty, toto zariadenie bude obmedzené na 4G. "<annotation id="url">"Ďalšie informácie"</annotation></string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Pozastavenie spúšťania aplikácií z vyrovnávacej pamäte"</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Povolenie prekrývajúcich prvkov v Nastaveniach"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Povoľte aplikácie, ktoré sa môžu zobraziť cez iné aplikácie, aby mohli prekryť obrazovky Nastavení"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Médiá"</string>
    <string name="media_controls_summary" msgid="3573121049460596520">"Prehrávač médií v rýchlych nastaveniach"</string>
    <string name="media_controls_resume_description" msgid="7702723104730495227">"Zobrazovať prehrávač médií dlhšie, aby bolo možné ľahko obnoviť prehrávanie"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Skryť prehrávač"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Zobraziť prehrávač"</string>
    <string name="media_controls_no_players" msgid="3493023121892175946">"K dispozícii nie sú žiadne prehrávače"</string>
    <string name="media_controls_apps_title" msgid="9129092193224838008">"Povolené aplikácie"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"médiá"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Zapne sa Bluetooth"</string>
    <string name="bluetooth_setting_on" msgid="4808458394436224124">"Zapnuté"</string>
    <string name="bluetooth_setting_off" msgid="4965493913199554789">"Vypnuté"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM karty"</string>
    <string name="airplane_safe_networks" msgid="6057114281183247124">"Zobrazenie sietí režimu v lietadle"</string>
    <string name="airplane_safe_networks_summary" msgid="4879620804022818385">"Nájdite siete v režime v lietadle a pripojte sa k nim."</string>
    <string name="keywords_airplane_safe_networks" msgid="5902708537892978245">"lietadlo, možné používať v lietadle"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Hovory a SMS"</string>
    <string name="calls_and_sms_category" msgid="2021321997884906046">"Volanie cez Wi‑Fi"</string>
    <!-- no translation found for calls_sms_wfc_summary (3940529919408667336) -->
    <skip />
    <!-- no translation found for calls_sms_footnote (8051604228144899434) -->
    <skip />
    <string name="calls_preference_title" msgid="7536882032182563800">"Hovory"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"preferované"</string>
    <string name="calls_sms_calls_preferred" msgid="252913858812799809">"preferujú sa hovory"</string>
    <string name="calls_sms_sms_preferred" msgid="5826706870873784062">"preferujú sa správy SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"nie je k dispozícii"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Žiadna SIM karta"</string>
    <string name="network_and_internet_preferences_title" msgid="8038469368705591439">"Predvoľby"</string>
    <string name="network_and_internet_preferences_summary" msgid="613207494152304537">"Pripájať k verejným sieťam"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"pripojenie k sieti, internet, bezdrôtové, dátové, wifi, wi-fi, wi fi, mobilné, mobilný operátor, 4g, 3g, 2g, lte"</string>
    <string name="view_airplane_safe_networks" msgid="9170023210981508906">"Zobraziť siete režimu v lietadle"</string>
    <string name="viewing_airplane_mode_networks" msgid="4548508852659577531">"Zobrazujú sa siete režimu v lietadle"</string>
    <string name="turn_off_airplane_mode" msgid="7141986366534514443">"Vypnúť režim v lietadle"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Chcete internet resetovať?"</string>
    <string name="reset_internet_text" product="default" msgid="8797910368942544453">"Týmto ukončíte telefonický hovor"</string>
    <string name="reset_internet_text" product="tablet" msgid="8797910368942544453">"Týmto ukončíte telefonický hovor"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Internet sa resetuje…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Odstrániť problém s pripojením"</string>
    <string name="airplane_mode_network_available" msgid="1059499681300395240">"Siete dostupné v režime v lietadle"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Ak chcete prepnúť siete, odpojte ethernet"</string>
    <!-- no translation found for cannot_switch_networks_while_connected (3867944849171754777) -->
    <skip />
    <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">"Pripojené"</string>
    <string name="mobile_data_off_summary" msgid="3841411571485837651">"Internet sa nepripojí automaticky"</string>
    <string name="non_carrier_network_unavailable" msgid="9031567407964127997">"Nie sú k dispozícii žiadne ďalšie siete"</string>
    <string name="all_network_unavailable" msgid="1163897808282057496">"Nie sú k dispozícii žiadne siete"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Nedostupné, pretože je zapnutý režim večierky"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Resetovanie dôležitosti upozornenia je dokončené."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Aplikácie"</string>
    <string name="bluetooth_message_access_notification_content" msgid="2986108412562309009">"Nedôveryhodné zariadenie vyžaduje prístup k vašim správam. Klepnutím zobrazíte podrobnosti."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Chcete povoliť prístup k správam?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="2304761898608701739">"Nedôveryhodné zariadenie <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> s rozhraním Bluetooth vyžaduje prístup k vašim správam.\n\nK zariadeniu <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> ste sa predtým nikdy nepripojili."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="4280361621526852063">"Nedôveryhodné zariadenie vyžaduje prístup k vašim kontaktom a zoznamu hovorov. Klepnutím zobrazíte podrobnosti."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Chcete povoliť prístup ku kontaktom a zoznamu hovorov?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="4766700015848574532">"Nedôveryhodné zariadenie <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> s rozhraním Bluetooth vyžaduje prístup k vašim kontaktom a zoznamu hovorov. Zahŕňa to údaje o prichádzajúcich a odchádzajúcich hovoroch.\n\nK zariadeniu <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> ste sa predtým nikdy nepripojili."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Jas"</string>
    <string name="category_name_lock_display" msgid="7478785189102882266">"Uzamknutá obrazovka"</string>
    <string name="category_name_visibility" msgid="4485030512199246405">"Viditeľnosť"</string>
    <string name="category_name_color" msgid="937514550918977151">"Farba"</string>
    <string name="category_name_others" msgid="2366006298768550310">"Iné"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Všeobecné"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Zobraziť všetky aplikácie"</string>
    <!-- no translation found for smart_forwarding_title (8368634861971949799) -->
    <skip />
    <!-- no translation found for smart_forwarding_summary_enabled (3341062878373185604) -->
    <skip />
    <!-- no translation found for smart_forwarding_summary_disabled (5033880700091914809) -->
    <skip />
    <!-- no translation found for smart_forwarding_ongoing_title (962226849074401228) -->
    <skip />
    <!-- no translation found for smart_forwarding_ongoing_text (2189209372407117114) -->
    <skip />
    <!-- no translation found for smart_forwarding_failed_title (1859891191023516080) -->
    <skip />
    <!-- no translation found for smart_forwarding_failed_text (5370431503707373653) -->
    <skip />
    <!-- no translation found for smart_forwarding_failed_not_activated_text (997396203001257904) -->
    <skip />
    <!-- no translation found for smart_forwarding_input_mdn_title (5105463748849841763) -->
    <skip />
    <!-- no translation found for smart_forwarding_input_mdn_dialog_title (7542216086697868415) -->
    <skip />
    <!-- no translation found for smart_forwarding_missing_mdn_text (2907314684242542226) -->
    <skip />
    <!-- no translation found for smart_forwarding_missing_alert_dialog_text (7870419247987316112) -->
    <skip />
</resources>
