<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2007 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
 -->

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="4676390750360727396">"Áno"</string>
    <string name="no" msgid="6731231425810196216">"Nie"</string>
    <string name="create" msgid="3578857613172647409">"Vytvoriť"</string>
    <string name="allow" msgid="3349662621170855910">"Povoliť"</string>
    <string name="deny" msgid="6947806159746484865">"Odmietnuť"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Neznáme"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="7201398282729229649">
      <item quantity="few">Ešte <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> krok 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="1110711554982716293">"Teraz ste vývojár!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Nie je to potrebné, už ste vývojár."</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Bezdrôtové pripojenie a siete"</string>
    <string name="header_category_connections" msgid="6471513040815680662">"Pripojenia"</string>
    <string name="header_category_device" msgid="4544026001618307754">"Zariadenie"</string>
    <string name="header_category_personal" msgid="3310195187905720823">"Osobné"</string>
    <string name="header_category_access" msgid="7580499097416970962">"Prístup"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Systém"</string>
    <string name="turn_on_radio" msgid="8706561489788373676">"Zapnúť rádio"</string>
    <string name="turn_off_radio" msgid="1820294552893884115">"Vypnúť rádio"</string>
    <string name="sms_over_ims_on" msgid="5085290395865632925">"Zapnúť správy SMS prostredníctvom IMS"</string>
    <string name="sms_over_ims_off" msgid="8354792045992793959">"Vypnúť správy SMS prostredníctvom IMS"</string>
    <string name="ims_reg_required_on" msgid="3885152087309614653">"Zapnúť požadovanie registrácie IMS"</string>
    <string name="ims_reg_required_off" msgid="1720570343422743943">"Vypnúť požadovanie registrácie IMS"</string>
    <string name="volte_provisioned_flag_on" msgid="6023503159480902956">"Zapnite poskytovaný príznak VoLTE"</string>
    <string name="volte_provisioned_flag_off" msgid="6168612015904744405">"Vypnite poskytovaný príznak VoLTE"</string>
    <string name="lte_ram_dump_on" msgid="8568568019520172177">"Zapnúť výpis pamäte lte ram"</string>
    <string name="lte_ram_dump_off" msgid="2514507918652378283">"Vypnúť výpis pamäte lte ram"</string>
    <string name="radioInfo_menu_viewADN" msgid="8743377494429930831">"Zobraziť adresár karty SIM"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Zobraziť čísla pevného vytáčania"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Zobraziť čísla volaní služieb"</string>
    <string name="radioInfo_menu_getPDP" msgid="560610293888406317">"Získať zoznam PDP"</string>
    <string name="radioInfo_service_in" msgid="1915416319177520020">"Činné"</string>
    <string name="radioInfo_service_out" msgid="5238736759641916278">"Nefunguje"</string>
    <string name="radioInfo_service_emergency" msgid="2485604591272668370">"Len tiesňové volania"</string>
    <string name="radioInfo_service_off" msgid="1434084741785525415">"Rádio je vypnuté"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="2851853244069662307">"Bez roamingu"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Nečinný"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Vyzváňanie"</string>
    <string name="radioInfo_phone_offhook" msgid="4174402846862780998">"Prebiehajúci hovor"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Odpojený"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Pripája sa"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Pripojené"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Pozastavená"</string>
    <string name="radioInfo_unknown" msgid="737385314432468266">"neznáme"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"pakety"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"B"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Odpoj. uklad. priestor USB"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Odpojiť kartu SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Vymazať ukladací priestor USB"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Vymazať kartu SD"</string>
    <string name="small_font" msgid="2295331917424072635">"Malé"</string>
    <string name="medium_font" msgid="2068475425515133701">"Stredné"</string>
    <string name="large_font" msgid="599055175160971446">"Veľké"</string>
    <string name="font_size_save" msgid="3450855718056759095">"OK"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Ukladací priestor USB"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"Karta SD"</string>
    <string name="battery_info_status_label" msgid="8109155295509700309">"Stav batérie:"</string>
    <string name="battery_info_power_label" msgid="7465140230991349382">"Napájací konektor:"</string>
    <string name="battery_info_scale_label" msgid="3649763192389778437">"Stupnica batérie:"</string>
    <string name="battery_info_level_label" msgid="8706526709307788737">"Stav batérie:"</string>
    <string name="battery_info_health_label" msgid="6416051542741886958">"Zdravie batérie:"</string>
    <string name="battery_info_technology_label" msgid="788304533220748681">"Technológia batérie:"</string>
    <string name="battery_info_voltage_label" msgid="8971764146757637863">"Napätie batérie:"</string>
    <string name="battery_info_voltage_units" msgid="8658490792208288107">"mV"</string>
    <string name="battery_info_temperature_label" msgid="1968383098818648037">"Teplota batérie:"</string>
    <string name="battery_info_temperature_units" msgid="9098950587249987550">"° C"</string>
    <string name="battery_info_uptime" msgid="5548545143573527992">"Čas od spustenia:"</string>
    <string name="battery_info_awake_battery" msgid="2557725975486185849">"Doba napájania z batérie:"</string>
    <string name="battery_info_awake_plugged" msgid="176716874713478188">"Doba používania počas nabíjania:"</string>
    <string name="battery_info_screen_on" msgid="376277447175613889">"Doba zapnutia obrazovky:"</string>
    <string name="battery_info_status_unknown" msgid="196130600938058547">"Neznáme"</string>
    <string name="battery_info_status_charging" msgid="1705179948350365604">"Nabíjanie"</string>
    <string name="battery_info_status_charging_ac" msgid="2909861890674399949">"Nabíjanie zo zásuvky"</string>
    <string name="battery_info_status_charging_usb" msgid="2207489369680923929">"Nabíjanie cez USB"</string>
    <string name="battery_info_status_charging_wireless" msgid="3574032603735446573">"Bezdrôtové nabíjanie"</string>
    <string name="battery_info_status_discharging" msgid="310932812698268588">"Nenabíja sa"</string>
    <string name="battery_info_status_not_charging" msgid="2820070506621483576">"Nenabíja sa"</string>
    <string name="battery_info_status_full" msgid="2824614753861462808">"Plná"</string>
    <string name="battery_info_power_unplugged" msgid="5987246575519551081">"Odpojené"</string>
    <string name="battery_info_power_ac" msgid="6808516193001604634">"AC"</string>
    <string name="battery_info_power_usb" msgid="8012931702516331797">"USB"</string>
    <string name="battery_info_power_wireless" msgid="6819163295739305097">"bezdrôtové"</string>
    <string name="battery_info_power_ac_usb" msgid="6777734146838328688">"AC+USB"</string>
    <string name="battery_info_power_unknown" msgid="7344115502868899881">"Neznáme"</string>
    <string name="battery_info_health_unknown" msgid="5664295556921944255">"Neznáme"</string>
    <string name="battery_info_health_good" msgid="8070356565806711806">"Dobrá"</string>
    <string name="battery_info_health_overheat" msgid="8442959549291368806">"Prehriata"</string>
    <string name="battery_info_health_dead" msgid="1725917445762829059">"Vybitá"</string>
    <string name="battery_info_health_over_voltage" msgid="2420269351664490121">"Prepätie"</string>
    <string name="battery_info_health_unspecified_failure" msgid="6347021103185471590">"Neznáma chyba"</string>
    <string name="battery_info_health_cold" msgid="3835692786176707318">"Studené"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"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="2849387702249327748">"Viditeľné pre všetky okolité zariadenia Bluetooth"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Neviditeľné pre ostatné zariadenia Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Viditeľné len pre spárované zariadenia"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Časový limit viditeľnosti"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Uzamknúť hlasové vytáčanie"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Zabrániť použitiu vytáčania Bluetooth pri uzamknutej obrazovke"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Zariadenia Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Názov zariadenia"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Nastavenia zariadenia"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Nastavenia profilu"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Názov nie je nastavený, použije sa názov účtu"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Vyhľadať zariadenia"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Premenovať toto zariadenie"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Premenovať"</string>
    <string name="bluetooth_disconnect_title" msgid="6026705382020027966">"Odpojiť?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="9148530542956217908">"Táto akcia ukončí vaše pripojenie so zariadením:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="1185354873716211496">"Nemáte povolenie na zmenu nastavení Bluetooth."</string>
    <string name="bluetooth_is_visible_message" msgid="6222396240776971862">"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_is_disconnect_question" msgid="5334933802445256306">"Odpojiť zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Vysielanie"</string>
    <string name="bluetooth_disable_profile_title" msgid="5916643979709342557">"Zakázať profil?"</string>
    <string name="bluetooth_disable_profile_message" msgid="2895844842011809904">"Táto akcia zakáže profil <xliff:g id="PROFILE_NAME">%1$s</xliff:g> a zariadenie <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="bluetooth_connected_no_headset" msgid="2866994875046035609">"Pripojené (bez telefónu)"</string>
    <string name="bluetooth_connected_no_a2dp" msgid="4576188601581440337">"Pripojené (bez média)"</string>
    <string name="bluetooth_connected_no_map" msgid="6504436917057479986">"Pripojené (bez prístupu ku správam)"</string>
    <string name="bluetooth_connected_no_headset_no_a2dp" msgid="9195757766755553810">"Pripojené (bez telefónu alebo média)"</string>
    <string name="bluetooth_unknown" msgid="644716244548801421"></string>
    <string name="bluetooth_pairing" msgid="1426882272690346242">"Párovanie..."</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Nepomenované zariadenie s rozhraním Bluetooth"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Vyhľadávanie"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"V blízk. nie sú žiadne zariad. Bluetooth."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Žiadosť o párovanie zariadenia Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Žiadosť na párovanie"</string>
    <string name="bluetooth_notif_message" msgid="5300852675110479862">"Zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> spárujete dotykom."</string>
    <string name="bluetooth_show_received_files" msgid="5164787486105868895">"Zobraziť prijaté súbory"</string>
    <string name="device_picker" msgid="4978696506172252813">"Vybrať zariadenie Bluetooth"</string>
    <string name="bluetooth_permission_request" msgid="1523129741266262748">"Žiadosť o povolenie zariadenia Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1712443355224737143">"Aplikácia chce ZAPNÚŤ Bluetooth pre toto zariadenie."</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="786921566047356213">"Aplikácia chce na <xliff:g id="TIMEOUT">%1$d</xliff:g> s prepnúť váš tablet do režimu, v ktorom bude viditeľný pre ostatné zariadenia Bluetooth."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="5510358858113713272">"Aplikácia chce na <xliff:g id="TIMEOUT">%1$d</xliff:g> s prepnúť váš telefón do režimu, v ktorom bude viditeľný pre ostatné zariadenia Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8863617309580598607">"Aplikácia chce váš tablet prepnúť do režimu, v ktorom bude viditeľný pre ostatné zariadenia Bluetooth. Toto nastavenie môžete neskôr zmeniť v nastaveniach rozhrania Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="6487606808683607975">"Aplikácia chce váš telefón prepnúť do režimu, v ktorom bude viditeľný pre ostatné zariadenia Bluetooth. Toto nastavenie môžete neskôr zmeniť v nastaveniach rozhrania Bluetooth."</string>
    <string name="bluetooth_ask_start_broadcast" product="default" msgid="3535628155254187911">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnúť vysielanie prostredníctvom rozhrania Bluetooth, aby mohla komunikovať s ostatnými zariadeniami v blízkosti. Toto nastavenie môžete neskôr zmeniť v sekcii Nastavenia Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_start_broadcast" product="default" msgid="8810858601242763295">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnúť funkciu Bluetooth a vysielanie prostredníctvom rozhrania Bluetooth, aby mohla komunikovať s ostatnými zariadeniami v blízkosti. Toto nastavenie môžete neskôr zmeniť v sekcii Nastavenia Bluetooth."</string>
    <string name="bluetooth_broadcasting_explaination" product="default" msgid="4249322115655011799">"Keď je táto funkcia zapnutá, váš telefón môže komunikovať s ostatnými zariadeniami v blízkosti.\n\nVysielanie používa signály Bluetooth s nízkou spotrebou energie."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="3346529092809011149">"Aplikácia chce na <xliff:g id="TIMEOUT">%1$d</xliff:g> s zapnúť rozhranie Bluetooth a prepnúť váš tablet do viditeľného režimu."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="4724094889807196118">"Aplikácia chce na <xliff:g id="TIMEOUT">%1$d</xliff:g> s zapnúť rozhranie Bluetooth a prepnúť váš telefón do viditeľného režimu."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="989613204829097159">"Aplikácia chce zapnúť rozhranie Bluetooth a prepnúť váš tablet do režimu, v ktorom bude viditeľný pre ostatné zariadenia. Toto nastavenie môžete neskôr zmeniť v nastaveniach rozhrania Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6671615712909139801">"Aplikácia chce zapnúť rozhranie Bluetooth a prepnúť váš telefón do režimu, v ktorom bude viditeľný pre ostatné zariadenia. Toto nastavenie môžete neskôr zmeniť v nastaveniach rozhrania Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Bluetooth sa zapína…"</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Bluetooth sa vypína…"</string>
    <string name="bluetooth_auto_connect" msgid="40711424456733571">"Automaticky pripojiť"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Žiadosť o pripojenie zariadenia Bluetooth"</string>
    <string name="bluetooth_connection_notif_message" msgid="3687933246423942977">"K zariadeniu „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“ sa pripojíte dotykom."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Chcete sa pripojiť k zariadeniu „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>“?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Žiadosť o prístup k telefónnemu zoznamu"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="6555508756987053866">"Zariadenie %1$s žiada o prístup k vašim kontaktom a histórii hovorov. Povoliť zariadeniu %2$s prístup?"</string>
    <string name="bluetooth_remember_choice" msgid="6198284561603824931">"Nabudúce sa nepýtať"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2901499974259177202">"Nabudúce sa nepýtať"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Žiadosť o prístup ku správam"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"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="date_and_time" msgid="9062980487860757694">"Dátum a čas"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Zvoľte časové pásmo"</string>
    <string name="display_preview_label" msgid="1127597250917274792">"Ukážka:"</string>
    <string name="display_font_size_label" msgid="8941851418397475389">"Veľkosť písma:"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Odoslať <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Spustiť <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Účet:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Server proxy"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Vymazať"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Port proxy:"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Nepoužívať server proxy pre"</string>
    <string name="proxy_exclusionlist_hint" msgid="6084099226687226948">"example.com,mycomp.test.com,localhost"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Obnoviť predvolené nastavenia"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Hotovo"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Názov hostiteľa servera proxy"</string>
    <string name="proxy_hostname_hint" msgid="2076157057003936176">"proxy.example.com"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Pozor"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="8052095511862922213">"Zadaný názov hostiteľa nie je platný."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6467799485443290961">"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="5539106187558215246">"Musíte vyplniť pole port."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Ak je pole hostiteľ prázdne, musí byť prázdne aj pole port."</string>
    <string name="proxy_error_invalid_port" msgid="2671425042711054494">"Zadaný port nie je platný."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Prehliadač používa server proxy pre protokol HTTP, ale ostatné aplikácie ho používať nemusia."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"Webová adresa PAC: "</string>
    <string name="radio_info_signal_location_label" msgid="16475158265551708">"Poloha:"</string>
    <string name="radio_info_neighboring_location_label" msgid="2385625674055934880">"Susedný identifikátor CID:"</string>
    <string name="radio_info_cellinfo_label" msgid="1300937728020622362">"CellInfo:"</string>
    <string name="radio_info_dcrtinfo_label" msgid="6802395441317448068">"Informácie:"</string>
    <string name="radio_info_data_attempts_label" msgid="1731106244577323381">"Pokusy údajov:"</string>
    <string name="radio_info_gprs_service_label" msgid="2331818110375395364">"Služba GPRS:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Roaming:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="1654674226961476872">"Presmerované hovory:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3241667824729310546">"Počet obnovení protokolu PPP od spustení:"</string>
    <string name="radio_info_gsm_disconnects_label" msgid="1683069665736339820">"Odpojenie od siete GSM:"</string>
    <string name="radio_info_current_network_label" msgid="3256402602440102610">"Aktuálna sieť:"</string>
    <string name="radio_info_data_successes_label" msgid="4417894113689054945">"Úspešné údaje:"</string>
    <string name="radio_info_ppp_received_label" msgid="3345184342444878849">"Prijaté protokoly PPP:"</string>
    <string name="radio_info_gsm_service_label" msgid="2082332114596916985">"Služba GSM:"</string>
    <string name="radio_info_signal_strength_label" msgid="1931937920896925766">"Sila signálu:"</string>
    <string name="radio_info_call_status_label" msgid="4896238900685510883">"Stav hovoru:"</string>
    <string name="radio_info_ppp_sent_label" msgid="5009102250704375687">"Odoslané informácie PPP:"</string>
    <string name="radio_info_radio_resets_label" msgid="9211343458143291617">"Obnovenia rádia:"</string>
    <string name="radio_info_message_waiting_label" msgid="6981842420058672207">"Čakajúce správy:"</string>
    <string name="radio_info_phone_number_label" msgid="7192944627907412169">"Telefónne číslo:"</string>
    <string name="radio_info_band_mode_label" msgid="441469694142042022">"Vybrať pásmo rádia"</string>
    <string name="radio_info_network_type_label" msgid="3706382548257257987">"Typ siete:"</string>
    <string name="radio_info_set_perferred_label" msgid="9039200405863503267">"Preferovaný typ siete:"</string>
    <string name="radio_info_ping_ipaddr" msgid="498747917793263530">"Použiť test Ping na IpAddr:"</string>
    <string name="radio_info_ping_hostname" msgid="3054888474808217853">"Otestovať dostupnosť hostiteľa (www.google.sk):"</string>
    <string name="radio_info_http_client_test" msgid="5733604021077701555">"Test klienta HTTP:"</string>
    <string name="ping_test_label" msgid="7255376471490860631">"Spustiť testovanie dostupnosti (ping)"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Aktualizovať"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Obnoviť"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="8292252930563286858">"Prepnúť kontrolu DNS"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Informácie a nastavenia špecifické pre výrobcu OEM"</string>
    <string name="band_mode_title" msgid="954174198903776205">"Nastaviť pásmo pre GSM a UMTS"</string>
    <string name="band_mode_loading" msgid="548764766363847336">"Prebieha načítavanie zoznamu pásiem..."</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Nastaviť"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Neúspešné"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Úspešné"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Zmena sa prejaví pri ďalšom pripojení kábla USB."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Povoliť veľkokapacitné pamäťové zariadenie USB"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Celková kapacita (bajty):"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"Úložisko USB nie je pripojené."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Žiadna karta SD."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Pamäť k dispozícii (bajty):"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"Úložisko USB sa používa ako veľkokapacitné pamäťové zariadenie."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"Karta SD sa používa ako veľkokapacitné pamäťové zariadenie."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="9191210735703409245">"Úložisko USB môžete odobrať."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="6462544066195404905">"Teraz môžete kartu SD bezpečne odobrať."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"Ukl. priestor USB odstr. počas prevádzky."</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"Karta SD bola odstránená počas prevádzky."</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Obsadená pamäť (bajty):"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Hľad. médií v ukl. priestore USB..."</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Vyhľadávanie mediálnych súborov na karte SD..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"Úložisko USB je pripojené len na čítanie."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"Karta SD bola pripojená iba na čítanie."</string>
    <string name="skip_label" msgid="47510779345218297">"Preskočiť"</string>
    <string name="next_label" msgid="4693520878012668114">"Ďalej"</string>
    <string name="language_picker_title" msgid="5349877711342869319">"Jazyk"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Zvoliť aktivitu"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Informácie o zariadení"</string>
    <string name="battery_info_label" msgid="4132685016148679403">"Informácie o batérii"</string>
    <string name="display_label" msgid="8074070940506840792">"Obrazovka"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Informácie o tablete"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informácie o telefóne"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Ukladací priestor USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"Karta SD"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Nastavenia servera proxy"</string>
    <string name="cancel" msgid="6859253417269739139">"Zrušiť"</string>
    <string name="cancel_all_caps" msgid="3183966387632229461">"ZRUŠIŤ"</string>
    <string name="continue_all_caps" msgid="5152713914673789893">"POKRAČOVAŤ"</string>
    <string name="okay" msgid="1997666393121016642">"OK"</string>
    <string name="yes_all_caps" msgid="5454685069075197457">"ÁNO"</string>
    <string name="no_all_caps" msgid="3242375449351298529">"NIE"</string>
    <string name="forget" msgid="7267115980248732932">"ODSTRÁNIŤ"</string>
    <string name="settings_label" msgid="1626402585530130914">"Nastavenia"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Nastavenia"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Odkaz na nastavenia"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Režim v lietadle"</string>
    <string name="radio_controls_title" msgid="3447085191369779032">"Ďalšie"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Bezdrôtové pripojenie a siete"</string>
    <string name="radio_controls_summary" msgid="2837395036275123133">"Spravovať sieť Wi-Fi, rozhranie Bluetooth, režim v lietadle, mobilné siete a siete VPN"</string>
    <string name="cellular_data_title" msgid="2525947635539415202">"Mobilné dáta"</string>
    <string name="calls_title" msgid="3544471959217176768">"Hovory"</string>
    <string name="sms_messages_title" msgid="1778636286080572535">"Správy SMS"</string>
    <string name="cellular_data_summary" msgid="4575500999626276446">"Povoliť využitie dát cez mobilnú sieť"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Povoliť využ. dát pri roamingu"</string>
    <string name="roaming" msgid="3596055926335478572">"Dátový roaming"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Pripájať sa k dátovým službám pri roamingu"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Pripájať sa k dátovým službám pri roamingu"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"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="4387601818162120589">"Zapnúť"</string>
    <string name="roaming_warning" msgid="7625933694709170887">"Ak povolíte dátový roaming, môžu sa vám účtovať vysoké poplatky."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Ak povolíte dátový roaming, môžu sa vám účtovať vysoké poplatky za roaming!\n\nToto nastavenie ovplyvní všetkých používateľov tohto tabletu."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Ak povolíte dátový roaming, môžu sa vám účtovať vysoké poplatky za roaming!\n\nToto nastavenie ovplyvní všetkých používateľov tohto telefónu."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Povoliť dátový roaming?"</string>
    <string name="networks" msgid="6333316876545927039">"Výber operátora"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Zvoliť sieťového operátora"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Dátum a čas"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Nastaviť dátum a čas"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Nastaviť dátum, čas, časové pásmo a formáty"</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Automatický dátum a čas"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Použiť čas zo siete"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Použiť čas zo siete"</string>
    <string name="zone_auto" msgid="334783869352026648">"Automatické časové pásmo"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Použiť časové pásmo zo siete"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Použiť časové pásmo zo siete"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"24-hodinový formát"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Použiť 24-hodinový formát"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Čas"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Nastavenie času"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Časové pásmo"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Voľba časového pásma"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Dátum"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Nastavenia dátumu"</string>
    <string name="zone_list_menu_sort_alphabetically" msgid="5683377702671088588">"Zoradiť v abecednom poradí"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="2720190443744884114">"Zoradiť podľa časového pásma"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Dátum"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Čas"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Automaticky zamknúť"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po prechode do spánku"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="5579064842797188409">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po režime spánku, ak odomknutie nie je udržované funkciou <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Zobrazovať vlastníka na uzamknutej obrazovke"</string>
    <string name="owner_info_settings_title" msgid="2723190010708381889">"Info o vlastníkovi"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Aktiv. miniaplikácie"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="1557090442377855233">"Zakázané správcom"</string>
    <string name="owner_info_settings_summary" msgid="3800834657847339570"></string>
    <string name="owner_info_settings_edit_text_hint" msgid="4608681417960923911">"Zadajte text, ktorý sa zobrazí na uzamknutej obrazovke"</string>
    <string name="show_user_info_on_lockscreen_label" msgid="8408914624925608365">"Zobrazovať používateľa na uzamknutej obrazovke"</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Inf. o používateľovi"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Zobraziť inform. o profile na uzamknutej obrazovke"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Informácie o profile"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Účty"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Poloha"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Účty"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Zabezpečenie"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Moja poloha, odomknutie obrazovky, zámok SIM, zámok ukladacieho priestoru poverení"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Nastavenie funkcie Moje poloha, odomknutie obrazovky a zamknutie úložiska poverení"</string>
    <string name="security_passwords_title" msgid="2930627259125138363">"Heslá"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2488725232406204350">"Odtlačok prsta"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="4776063289827470602">
      <item quantity="few"><xliff:g id="COUNT_1">%1$d</xliff:g> zaregistrované odtlačky</item>
      <item quantity="many"><xliff:g id="COUNT_1">%1$d</xliff:g> zaregistrovaných odtlačkov</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> zaregistrovaných odtlačkov</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> zaregistrovaný odtlačok</item>
    </plurals>
    <string name="security_settings_fingerprint_enroll_onboard_title" msgid="4735546436672054254">"Nastavenie odtlačku"</string>
    <string name="security_settings_fingerprint_enroll_onboard_message" msgid="8275201068478623705">"Na to, aby ste mohli používať odtlačok prsta na odomknutie obrazovky alebo potvrdenie nákupov, musíte: \n✓ Nastaviť zámku obrazovky pozadia \n✓ Pridať odtlačok prsta"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="1063375657071124812">"Začíname!"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="6294541599045187369">"Priložte prst na snímač odtlačkov. Keď ucítite vibráciu, zdvihnite ho."</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="3732060789409510229">"Skvelé! Ešte raz."</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="8846866512704467036">"Priložte ten istý prst na snímač odtlačkov. Keď ucítite vibráciu, zdvihnite ho."</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="4798692662828257300">"Odtlačok bol pridaný!"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="835496875787664316">"Kedykoľvek uvidíte túto ikonu, môžete na identifikáciu alebo povolenie nákupu použiť odtlačok prsta."</string>
    <string name="fingerprint_enroll_button_add" msgid="9087063833311608281">"Pridať"</string>
    <string name="fingerprint_enroll_button_next" msgid="6247009337616342759">"Ďalej"</string>
    <string name="fingerprint_acquired_try_again" msgid="3543246847519773670">"Podarilo sa nám rozpoznať iba časť odtlačku. Skúste to znova."</string>
    <string name="fingerprint_acquired_imager_dirty" msgid="1069333738311915876">"Snímač odtlačkov je špinavý. Vyčistite ho a skúste to znova."</string>
    <string name="fingerprint_acquired_too_fast" msgid="4068036120000203641">"Pohli ste prstom príliš rýchlo. Skúste to znova."</string>
    <string name="fingerprint_acquired_too_slow" msgid="1030658686087736299">"Pohli ste prstom príliš pomaly. Skúste to znova."</string>
    <string name="fingerprint_error_unable_to_process" msgid="3695170439991347449">"Došlo k chybe spracovania. Skúste to znova."</string>
    <string name="fingerprint_error_hw_not_available" msgid="3535489559110151108">"Hardvér nie je k dispozícii"</string>
    <string name="fingerprint_error_no_space" msgid="7350970359618153619">"Odtlačok prsta nie je možné uložiť. Odstráňte existujúci odtlačok."</string>
    <string name="fingerprint_error_timeout" msgid="7509454501138740556">"Časový limit rozpoznania odtlačku vypršal. Skúste to znova."</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Šifrovanie"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Šifrovať tablet"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Šifrovať telefón"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Šifrované"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="2876073029767953111">"Svoje účty, nastavenia, stiahnuté aplikácie a ich údaje, médiá a ďalšie súbory môžete zašifrovať. Ak tablet zašifrujete a nastavili ste zámok obrazovky (bezpečnostné gesto, čí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 továrenských nastavení, ktorým vymažete všetky svoje údaje.\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 údaje."</string>
    <string name="crypt_keeper_desc" product="default" msgid="5573427498609458721">"Svoje účty, nastavenia, stiahnuté aplikácie a ich údaje, médiá a ďalšie súbory môžete zašifrovať. Ak telefón zašifrujete a nastavili ste zámku obrazovky (bezpečnostné gesto, čí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 továrenských nastavení, ktorým vymažete všetky svoje údaje.\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 údaje."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Šifrovať tablet"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Šifrovať telefón"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Nabite batériu a skúste to znova."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Zapojte nabíjačku a skúste to znova."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Chýba heslo alebo kód PIN na odomknutie obrazovky"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Pred spustením šifrovania musíte nastaviť kód PIN alebo heslo zámky obrazovky."</string>
    <string name="crypt_keeper_confirm_encrypt" msgid="736289627726831055">"Zašifrovanie zariadenia musíte potvrdiť nakreslením bezpečnostného vzoru."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Šifrovať?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="4453629424172409792">"Operácia šifrovania je nevratná a ak ju prerušíte, prídete o údaje. Š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="5682944380460921880">"Operácia šifrovania je nevratná a ak ju prerušíte, prídete o údaje. Š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="1783951453124244969">"Šifrovanie"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Č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="951918761585534875">"Č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="1655047311546745695">"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="1862964662304683072">"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="556504311511212648">"Ak chcete odomknúť svoj tablet, vypnite ho a potom ho zapnite."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="1794353635603020327">"Ak chcete odomknúť svoj telefón, vypnite ho a potom ho zapnite."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"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="2223340178473871064">"Zadajte svoje heslo"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Šifrovanie bolo neúspešné"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="4478225241476039013">"Š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 továrenské 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="3083477162766772532">"Š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 továrenské 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="8759119849089795751">"Dešifrovanie sa nepodarilo"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="3775740783651700375">"Zadané heslo je správne, avšak údaje sú poškodené. \n\nAk chcete ďalej používať svoj tablet, musíte obnoviť jeho továrenské 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="6898436151871328007">"Zadané heslo je správne, avšak údaje sú poškodené. \n\nAk chcete ďalej používať svoj telefón, musíte obnoviť jeho továrenské 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="4168332125223483198">"Prepnúť metódu vstupu"</string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Zámka obrazovky"</string>
    <string name="backup_lock_settings_picker_title" msgid="8530380598637963916">"Vybrať zámku zálohy"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Zámka obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Zmeniť uzamknutie obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Zmeniť alebo zakázať bezpečnostný vzor, kód PIN alebo heslo"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Vyberte spôsob uzamknutia obrazovky"</string>
    <string name="unlock_backup_info_summary" msgid="108524727803788172">"Ako chcete zariadenie odomknúť v prípade, že vás aplikácia Odomknutie tvárou nevidí?"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Žiadne"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Prejdenie prstom"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Bez zabezpečenia"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Vzor"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Stredné zabezpečenie"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Stredné až vysoké zabezpečenie"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Heslo"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Vysoké zabezpečenie"</string>
    <string name="unlock_disable_frp_warning_content" msgid="7070131836291098244">"Bezpečnostné funkcie zariadenia nebudú ďalej fungovať"</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2120729867788851674">"Zakázané správcom, pravidlom šifrovania alebo úložiskom poverení"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Žiadne"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Prejdenie prstom"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Vzor"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Heslo"</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Vypnúť zámku obrazovky"</string>
    <string name="unlock_disable_lock_pattern_summary" msgid="6801602880568869201">"Odstrániť bezpečnostný vzor"</string>
    <string name="unlock_disable_lock_pin_summary" msgid="8856842745366993387">"Odstrániť bezpečnostný kód PIN"</string>
    <string name="unlock_disable_lock_password_summary" msgid="192161194564577025">"Odstrániť bezpečnostné heslo"</string>
    <string name="unlock_disable_lock_unknown_summary" msgid="8688498722601653961">"Odstránenie zámky obrazovky"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Zmena bezpečnostného vzoru"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Zmena bezpečnostného kódu PIN"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Zmeniť bezpečnostné heslo"</string>
    <string name="lockpassword_password_too_short" msgid="7328975683669256660">"Heslo musí obsahovať najmenej %d znakov"</string>
    <string name="lockpassword_pin_too_short" msgid="1677649103470518953">"Kód PIN musí obsahovať najmenej %d číslic"</string>
    <string name="lockpassword_press_continue" msgid="122706614386757182">"Po dokončení sa dotknite tlačidla Pokračovať"</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Pokračovať"</string>
    <string name="lockpassword_password_too_long" msgid="7016906583950201704">"Heslo musí mať menej ako <xliff:g id="NUMBER">%d</xliff:g> znakov."</string>
    <string name="lockpassword_pin_too_long" msgid="6419879099090294052">"Kód PIN musí mať menej ako <xliff:g id="NUMBER">%d</xliff:g> číslic."</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="1079053457942945709">"Kód PIN musí obsahovať len číslice 0 až 9."</string>
    <string name="lockpassword_pin_recently_used" msgid="7909781183925861119">"Správca zariadení neumožňuje používanie nedávneho kódu PIN."</string>
    <string name="lockpassword_illegal_character" msgid="8742901630116866738">"Heslo obsahuje neplatný znak."</string>
    <string name="lockpassword_password_requires_alpha" msgid="5203836082520634764">"Heslo musí obsahovať najmenej jedno písmeno."</string>
    <string name="lockpassword_password_requires_digit" msgid="3958033271435659825">"Heslo musí obsahovať najmenej jednu číslicu."</string>
    <string name="lockpassword_password_requires_symbol" msgid="7226621405629726899">"Heslo musí obsahovať najmenej jeden symbol."</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="5677371623980347934">
      <item quantity="few">Heslo musí obsahovať najmenej %d písmená</item>
      <item quantity="many">Heslo musí obsahovať najmenej %d písmena</item>
      <item quantity="other">Heslo musí obsahovať najmenej %d písmen</item>
      <item quantity="one">Heslo musí obsahovať najmenej 1 písmeno</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="5396846200894553640">
      <item quantity="few">Heslo musí obsahovať najmenej %d malé písmená</item>
      <item quantity="many">Heslo musí obsahovať najmenej %d malého písmena</item>
      <item quantity="other">Heslo musí obsahovať najmenej %d malých písmen</item>
      <item quantity="one">Heslo musí obsahovať najmenej 1 malé písmeno</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="2483949715040341677">
      <item quantity="few">Heslo musí obsahovať najmenej %d veľké písmená</item>
      <item quantity="many">Heslo musí obsahovať najmenej %d veľkého písmena</item>
      <item quantity="other">Heslo musí obsahovať najmenej %d veľkých písmen</item>
      <item quantity="one">Heslo musí obsahovať najmenej 1 veľké písmeno</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="9156410893744210033">
      <item quantity="few">Heslo musí obsahovať najmenej %d číslice</item>
      <item quantity="many">Heslo musí obsahovať najmenej %d číslice</item>
      <item quantity="other">Heslo musí obsahovať najmenej %d číslic</item>
      <item quantity="one">Heslo musí obsahovať najmenej 1 číslicu</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="5384442837439742233">
      <item quantity="few">Heslo musí obsahovať najmenej %d špeciálne symboly</item>
      <item quantity="many">Heslo musí obsahovať najmenej %d špeciálneho symbolu</item>
      <item quantity="other">Heslo musí obsahovať najmenej %d špeciálnych symbolov</item>
      <item quantity="one">Heslo musí obsahovať najmenej 1 špeciálny symbol</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="4175064976268466293">
      <item quantity="few">Heslo musí obsahovať najmenej %d znaky iné ako písmeno</item>
      <item quantity="many">Heslo musí obsahovať najmenej %d znaku iného ako písmeno</item>
      <item quantity="other">Heslo musí obsahovať najmenej %d znakov iných ako písmeno</item>
      <item quantity="one">Heslo musí obsahovať najmenej 1 znak iný ako písmeno</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="6098087796784262081">"Správca zariadení neumožňuje používanie nedávneho hesla."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="6830610582179569631">"Vzostupná, zostupná alebo opakovaná sekvencia čísiel je zakázaná"</string>
    <string name="lockpassword_ok_label" msgid="313822574062553672">"OK"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Zrušiť"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Zrušiť"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Ďalej"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Nastavenie je dokončené."</string>
    <string name="device_admin_title" msgid="3562216873644263804">"Správa zariadenia"</string>
    <string name="manage_device_admin" msgid="5059296715271077278">"Správcovia zariadenia"</string>
    <string name="manage_device_admin_summary" msgid="7672709110988761075">"Zobraziť alebo deaktivovať správcov zariadenia"</string>
    <string name="manage_trust_agents" msgid="4629279457536987768">"Agenty dôvery"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Pred použitím musíte najskôr nastaviť zámku obrazovky"</string>
    <string name="manage_trust_agents_summary" msgid="6804319935640148441">"Zobrazenie alebo deaktivácia agentov dôvery"</string>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Zapnúť Bluetooth"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Správa pripojenia, nastavenie názvu zariadenia a viditeľnosti"</string>
    <string name="bluetooth_pairing_request" msgid="6385750334766370310">"Žiadosť o párovanie zariadenia Bluetooth"</string>
    <string name="bluetooth_enter_pin_msg" msgid="4954085254142996877">"Zariadenie"</string>
    <string name="bluetooth_pairing_key_msg" msgid="333005542843637754">"Párovací kód"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Zadajte párovací kód a potom stlačte tlačidlo Return alebo Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"Kód PIN obsahuje písmená alebo symboly"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Obvykle 0000 alebo 1234"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Tento kód PIN bude možno treba zadať aj na druhom zariadení."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Tento prístupový kľúč možno bude potrebné zadať aj v druhom zariadení."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"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="1615930853859551491">"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="2796550001376088433">"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_will_share_phonebook" msgid="4982239145676394429">"Párovaním udelíte zariadeniam po pripojení prístup k svojim kontaktom a histórii hovorov."</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_connecting_error_message" msgid="229861986106185022">"Nepodarilo sa pripojiť k zariadeniu <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Vyhľadať zariadenia"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Obnoviť"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Vyhľadávanie..."</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Nastavenie zariadenia"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Spárované zariadenie"</string>
    <string name="bluetooth_preference_paired_dialog_name_label" msgid="8111146086595617285">"Meno"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Internetové pripojenie"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Klávesnica"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Kontakty a história hovorov"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Spárovať s týmto zariadením?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Zdieľať telefónny zoznam?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"<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="8451248193517851958">"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_paired_devices" msgid="1970524193086791964">"Párované zariadenia"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Dostupné zariadenia"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"Nie sú k dispozícii žiadne zariadenia"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Pripojiť"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Odpojiť"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Párovať a pripojiť"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Zrušiť párovanie"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Odpojiť a zrušiť párovanie"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Možnosti…"</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Rozšírené"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Rozšírené nastavenia Bluetooth"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Keď je zapnutá funkcia Bluetooth, zariadenie môže komunikovať s ostatnými zariadeniami Bluetooth v okolí."</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Pripojiť k…"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"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="8635908811168780720">"Zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojené od zvukovej jednotky handsfree."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"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="8037627994382458698">"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="5455448395850929200">"Zariadenie <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="5266851881175033601">"Zariadenie <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="6066342531927499308">"Spárované zariadenia Bluetooth"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Pripojiť"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Umožňuje pripojenie zariadenia s rozhraním Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Použitie"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Premenovať"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Povoliť prichádzajúce prenosy súborov"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="4602294638909590612">"Pripoj. k zariad. s príst. na Internet"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1561383706411975199">"Zdieľa miestne internet. pripoj. so zariad"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Nastavenia doku"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Použiť zvuk doku"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Ako reproduktor telefónu"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Pre hudbu a médiá"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Zapamätať nastavenia"</string>
    <string name="wifi_assistant_title" msgid="2553267316621598101">"Wi‑Fi Assistant"</string>
    <string name="wifi_display_settings_title" msgid="2925465988657380522">"Prenos obrazovky"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Povoliť bezdrôtový displej"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"V okolí sa nenašli žiadne zariadenia."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Prepája sa"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Pripojené"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"Používa sa"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Nie je k dispozícii"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Nastavenia obrazovky"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Možnosti bezdrôtového displeja"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Odstrániť"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Hotovo"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Názov"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Povoliť výmenu údajov, ak sa tablet dotýka iného zariadenia"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Povoliť výmenu údajov, ak sa telefón dotýka iného zariadenia"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Prenos obsahu aplikácie prostredníctvom technológie NFC je pripravený"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Vyp."</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Nedostupné, pretože je vypnutá technológia NFC"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="6981652347448777459">"Ak 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. Napríklad môžete odosielať stránky prehliadača, videá YouTube, osobné kontakty a ďalšie.\n\nStačí priložiť zariadenia k sebe (obyčajne zadnými stranami) a potom sa dotknúť obrazovky. Aplikácia určí, aký obsah bude odoslaný."</string>
    <string name="nsd_quick_toggle_title" msgid="3125572815278848258">"Vyhľadávanie sieťových služieb"</string>
    <string name="nsd_quick_toggle_summary" msgid="155692215972781276">"Povoliť aplikáciám v iných zariadeniach hľadať aplikácie v tomto zariadení"</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Zapnúť Wi-Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Nastavenia Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi-Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Umožňuje nastaviť a spravovať prístupové body bezdrôtovej siete"</string>
    <string name="wifi_setup_wizard_title" msgid="7873622558088429710">"Výber siete Wi-Fi"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Vybrať sieť Wi-Fi"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Prebieha zapínanie siete Wi-Fi..."</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Prebieha vypínanie Wi-Fi..."</string>
    <string name="wifi_error" msgid="3207971103917128179">"Chyba"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"Režim v lietadle"</string>
    <string name="wifi_notify_open_networks" msgid="3755768188029653293">"Upozornenie na sieť"</string>
    <string name="wifi_notify_open_networks_summary" msgid="3716818008370391253">"Upozorniť, keď bude dostupná verejná sieť"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Vyhnúť sa nekvalitným pripojeniam"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7843672905900544785">"Nepoužívať sieť Wi-Fi, pokiaľ nemá dostatočne kvalitné internetové pripojenie"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4674423884870027498">"Použiť iba siete s dobrým pripojením k internetu"</string>
    <string name="wifi_scan_always_available" msgid="3470564139944368030">"Vyhľadávanie vždy zapnuté"</string>
    <string name="wifi_scan_always_available_title" msgid="1518769058260729007">"Vyhľadávanie vždy zapnuté"</string>
    <string name="wifi_scan_always_available_summary" msgid="5442775583708315387">"Povoliť službe určovania polohy Google a ostatným aplikáciám vyhľadávať siete aj v prípade, že je sieť Wi-Fi vypnutá"</string>
    <string name="wifi_automatically_connect_title" msgid="7950640291510621742">"Automaticky používať otvor. siete Wi‑Fi"</string>
    <string name="wifi_automatically_connect_summary" msgid="6722194413023965902">"Umožniť asistentovi Wi‑Fi automaticky sa pripojiť k otvoreným sieťam, ktoré určí ako vysokokvalitné"</string>
    <string name="wifi_select_assistant_dialog_title" msgid="4014645210955009439">"Výber asistenta"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Inštalácia certifikátov"</string>
    <string name="wifi_scan_notify_text_location_on" msgid="8135076005488914200">"Služby Google a ďalšie aplikácie môžu s cieľom zvýšenia presnosti a inými cieľmi vyhľadávať siete v blízkosti aj v prípade, že je sieť Wi-Fi vypnutá. Ak chcete nastavenie zmeniť, prejdite do časti Rozšírené &gt; Vyhľadávanie vždy zapnuté"</string>
    <string name="wifi_scan_notify_text_location_off" msgid="6323983741393280935">"Aplikácie môžu vyhľadávať siete v blízkosti aj v prípade, že je sieť Wi-Fi vypnutá. Ak chcete nastavenie zmeniť, prejdite do časti Rozšírené &gt; Vyhľadávanie vždy zapnuté."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="5340097010842405981">"Túto správu znova nezobrazovať"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Ponechať Wi-Fi zapnuté v režime spánku"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"Wi‑Fi aktívne v režime spánku"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Pri zmene nastavení sa vyskytol problém"</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Zlepšiť výkonnosť"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimalizácia Wi-Fi"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Minimalizovať spotrebu batérie pri zapnutej sieti Wi-Fi"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Obmedz. využitie batérie sieťou Wi-Fi"</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Pridať sieť"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Siete Wi-Fi"</string>
    <string name="wifi_menu_wps_pbc" msgid="2668564692207863017">"Tlačidlo WPS"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Ďalšie možnosti"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"Zadanie kódu WPS PIN"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Wi-Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Vyhľadávanie"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Rozšírené"</string>
    <string name="wifi_menu_apps" msgid="6003687912727859577">"Zobraziť aplikácie"</string>
    <string name="wifi_menu_apps_strength" msgid="3322614241441509660">"Zobraziť silu Wi-Fi"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Pripojiť k sieti"</string>
    <string name="wifi_menu_remember" msgid="8814185749388713796">"Zapamätať sieť"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Odstrániť záznam siete"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Upraviť sieť"</string>
    <string name="wifi_menu_write_to_nfc" msgid="7692881642188240324">"Zápis do značky NFC"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Ak chcete zobraziť dostupné siete, zapnite Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Prebieha vyhľadávanie sietí Wi-Fi..."</string>
    <string name="wifi_empty_list_user_restricted" msgid="8280257225419947565">"Nemáte povolenie na zmenu siete Wi-Fi."</string>
    <string name="wifi_other_network" msgid="1484433183857764750">"Pridať ďalšiu sieť"</string>
    <string name="wifi_more" msgid="3195296805089107950">"Viac"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Automatické nastavenie (WPS)"</string>
    <string name="wifi_required_info_text" msgid="7442238187557620087">"Tablet potrebuje na dokončenie nastavení prístup k sieti Wi-Fi. Po nastavení môžete prepínať medzi mobilným dátovým pripojením a sieťou Wi-Fi."</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Rozšírené možnosti"</string>
    <string name="wifi_wps_setup_title" msgid="8207552222481570175">"Chránené nastavenie siete Wi-Fi"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"Spúšťanie WPS…"</string>
    <string name="wifi_wps_onstart_pbc" msgid="5940801028985255304">"Stlačte na svojom smerovači tlačidlo Chránené nastavenie Wi-Fi. Môže byť označené písmenami WPS alebo týmto symbolom:"</string>
    <string name="wifi_wps_onstart_pin" msgid="223344506445335358">"Zadajte na svojom smerovači siete Wi-Fi kód PIN <xliff:g id="NUMBER">%1$s</xliff:g>. Proces nastavenia môže trvať až dve minúty."</string>
    <string name="wifi_wps_complete" msgid="2388138550456729134">"Spustenie WPS sa podarilo. Prebieha pripájanie k sieti…"</string>
    <string name="wifi_wps_connected" msgid="7153432445748931183">"Pripojené k sieti Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_wps_in_progress" msgid="3372311348221357944">"WPS prebieha a dokončenie procesu môže trvať až dve mnúty"</string>
    <string name="wifi_wps_failed_generic" msgid="5668775022238832527">"Spustenie WPS zlyhalo. Skúste to znova o niekoľko minút."</string>
    <string name="wifi_wps_failed_wep" msgid="2702820087105284461">"Nastavenie zabezpečenia bezdrôtového smerovača (TKIP) nie je podporované"</string>
    <string name="wifi_wps_failed_tkip" msgid="4282401586860713349">"Nastavenie zabezpečenia bezdrôtového smerovača (TKIP) nie je podporované"</string>
    <string name="wifi_wps_failed_auth" msgid="1174614355181181958">"Zlyhanie overenia totožnosti. Skúste to znova."</string>
    <string name="wifi_wps_failed_overlap" msgid="5159533685596844778">"Bola rozpoznaná ďalšia relácia WPS. Skúste to znova o niekoľko minút."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Názov siete"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Zadajte SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Zabezpečenie"</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Sila signálu"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Stav"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Rýchlosť pripojenia"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Frekvencia"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"Adresa IP"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"Metóda EAP"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Overenie – 2. fáza"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"Certifikát CA"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Certifikát používateľa"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identita"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Anonymná identita"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Heslo"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Zobrazovať heslo"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"Nastavenia adresy IP"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(nezmenené)"</string>
    <string name="wifi_unspecified" msgid="5431501214192991253">"(neurčené)"</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WPS je k dispozícii"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (WPS je k dispozícii)"</string>
    <string name="wifi_wps_nfc_enter_password" msgid="2288214226916117159">"Zadajte heslo siete"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"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_turnoff_message" msgid="5538901671131941043">"Ak chcete toto nastavenie vypnúť, prejdite do rozbaľovacej ponuky Rozšírené."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Povoliť"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Odmietnuť"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Chcete sa prihlásiť, aby ste sa mohli pripojiť?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"<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="5065506390164939225">"PRIPOJIŤ"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Pripojiť"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Nepodarilo sa pripojiť k sieti"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Odstrániť"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Nepodarilo sa odstrániť záznam siete"</string>
    <string name="wifi_save" msgid="3331121567988522826">"Uložiť"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Nepodarilo sa uložiť sieť"</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Zrušiť"</string>
    <string name="wifi_skip_anyway" msgid="6965361454438011190">"Preskočiť aj tak"</string>
    <string name="wifi_dont_skip" msgid="7350341524881124808">"Nepreskočiť"</string>
    <string name="wifi_skipped_message" product="tablet" msgid="6761689889733331124">"UPOZORNENIE: Ak nastavenie siete Wi‑Fi preskočíte, tablet na stiahnutie počiatočných súborov a aktualizácií použije iba mobilné dátové pripojenie. Ak chcete zabrániť možným poplatkom za prenos dát, pripojte sa k sieti Wi-Fi."</string>
    <string name="wifi_skipped_message" product="device" msgid="1385490367826852775">"UPOZORNENIE: Ak nastavenie siete Wi‑Fi preskočíte, zariadenie na stiahnutie počiatočných súborov a aktualizácií použije iba mobilné dátové pripojenie. Ak chcete zabrániť možným poplatkom za prenos dát, pripojte sa k sieti Wi-Fi."</string>
    <string name="wifi_skipped_message" product="default" msgid="6084295135297772350">"UPOZORNENIE: Ak nastavenie siete Wi‑Fi preskočíte, telefón na stiahnutie počiatočných súborov a aktualizácií použije iba mobilné dátové pripojenie. Ak chcete zabrániť možným poplatkom za prenos dát, pripojte sa k sieti Wi-Fi."</string>
    <string name="wifi_and_mobile_skipped_message" product="tablet" msgid="5872240361944591105">"Ak preskočíte pripojenie Wi‑Fi:\n\nváš tablet nebude pripojený k internetu;\n\naktualizácie softvéru získate až po pripojení k internetu;\n\nnebudete môcť aktivovať funkcie ochrany zariadenia."</string>
    <string name="wifi_and_mobile_skipped_message" product="device" msgid="1013689568018268332">"Ak preskočíte pripojenie Wi‑Fi:\n\nvaše zariadenie nebude pripojené k internetu;\n\naktualizácie softvéru získate až po pripojení k internetu;\n\nnebudete môcť aktivovať funkcie ochrany zariadenia."</string>
    <string name="wifi_and_mobile_skipped_message" product="default" msgid="5245835374169369770">"Ak preskočíte pripojenie Wi‑Fi:\n\nváš telefón nebude pripojený k internetu;\n\naktualizácie softvéru získate až po pripojení k internetu;\n\nnebudete môcť aktivovať funkcie ochrany zariadenia."</string>
    <string name="wifi_connect_failed_message" product="tablet" msgid="4474691090681670156">"Tablet sa k tejto sieti Wi-Fi nedokázal pripojiť."</string>
    <string name="wifi_connect_failed_message" product="device" msgid="8870885845666880869">"Zariadenie sa k tejto sieti Wi-Fi nedokázalo pripojiť."</string>
    <string name="wifi_connect_failed_message" product="default" msgid="2185803140161396572">"Telefón sa k tejto sieti Wi-Fi nedokázal pripojiť."</string>
    <string name="wifi_saved_access_points_titlebar" msgid="2996149477240134064">"Uložené siete"</string>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Rozšírené nastavenia Wi-Fi"</string>
    <string name="wifi_setting_frequency_band_title" msgid="3655327399028584656">"Frekvenčné pásmo Wi-Fi"</string>
    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Uveďte prevádzkový frekvenčný rozsah"</string>
    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Pri nast. pravidiel frekv. pásma nastal problém."</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Adresa MAC"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Adresa IP"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Uložené siete"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"Nastavenia adresy IP"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Uložiť"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Zrušiť"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Zadajte platnú adresu IP."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Zadajte platnú adresu brány."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Zadajte platnú adresu DNS."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Zadajte dĺžku sieťovej predpony v rozsahu 0 až 32."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"Server DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"Server DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Brána"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Dĺžka sieťovej predpony"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Wi‑Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Informácie o zariadení"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Zapamätať si toto pripojenie"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Vyhľadávanie zariadení"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Prebieha vyhľadávanie..."</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Premenovať zariadenie"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Partnerské zariadenia"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Zapamätané skupiny"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8921447388048243547">"Nepodarilo sa pripojiť."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Premenovanie zariadenia zlyhalo."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Odpojiť?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"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="3283805371034883105">"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="255267538099324413">"Zrušiť pozvánku?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"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="834559380069647086">"Odstrániť túto skupinu?"</string>
    <string name="wifi_tether_checkbox_text" msgid="1847167643625779136">"Prenosný hotspot Wi-Fi"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"Hotspot Wi‑Fi"</string>
    <string name="wifi_hotspot_checkbox_text_summary" msgid="3800646230853724318">"Poskytovať pripoj. k Wi-Fi pomocou mobil. pripoj."</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Prebieha zapínanie hotspotu..."</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Prebieha vypínanie hotspotu..."</string>
    <string name="wifi_tether_enabled_subtext" msgid="8948641212931906143">"Prenosný prístupový bod <xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktívny"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Chyba hotspotu siete Wi-Fi"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Nastaviť hotspot siete Wi-Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Nastavenie hotspotu Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5618031116920832182">"Prenos. hotspot Wi‑Fi AndroidAP WPA2 PSK"</string>
    <string name="wifi_tether_configure_subtext" msgid="7957547035983257748">"Prenosný hotspot siete Wi-Fi <xliff:g id="NETWORK_SSID">%1$s</xliff:g> <xliff:g id="NETWORK_SECURITY">%2$s</xliff:g>"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"AndroidHotspot"</string>
    <string name="home_settings" msgid="212375129455718176">"Domovská stránka"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Zobraziť"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Zvuk"</string>
    <string name="ringtone_summary" msgid="2630023412632683493"></string>
    <string name="all_volume_title" msgid="4296957391257836961">"Hlasitosti"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Hudobné efekty"</string>
    <string name="ring_volume_title" msgid="7938706566797464165">"Hlasitosť vyzváňania"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibrovať v tichom režime"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Predvolené zvukové upozornenie"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Tón zvonenia"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Upozornenie"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Použije hlasitosť prichádzajúcich hovorov aj pre upozornenia"</string>
    <string name="home_work_profile_not_supported" msgid="1357721012342357037">"Nepodporuje pracovné profily"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Predvolené zvukové upozornenie"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Médiá"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Umožňuje nastaviť hlasitosť hudby a videí"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Budík"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Nastavenia zvuku pre pripojený dok"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Zvuky pri dotyku číselníku"</string>
    <string name="sound_effects_enable_title" msgid="1171590821131077296">"Zvuky dotyku"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Zvuk uzamknutia obrazovky"</string>
    <string name="haptic_feedback_enable_title" msgid="2438293710530828760">"Vibrovanie pri dotyku"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Potlačenie šumu"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Hudba, video, hry a ďalšie médiá"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Zvonenie a upozornenia"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Upozornenia"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Budíky"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Vypnúť zvuk tónu zvonenia a upozornení"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Vypnúť zvuk hudby a iných médií"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Vypnúť zvuk upozornení"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Vypnúť zvuk budíka"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Dok"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Nastavenie doku"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Zvuk"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Nastavenia pripojeného stolného doku"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Nastavenia pripojeného doku do auta"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tablet nie je vložený do doku"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefón nie je vložený do doku"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Nastavenia pripojeného doku"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Dok nebol nájdený"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Pred nastavením zvuku doku v ňom musí byť vložený tablet."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Pred nastavením zvuku doku v ňom musí byť vložený telefón."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Zvuk pri vkladaní do doku"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Prehrať zvuk pri vkladaní alebo odstraňovaní tabletu z doku"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Prehrať zvuk pri vkladaní alebo odstraňovaní telefónu z doku"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="5077843049805652363">"Neprehrávať zvuk pri vkladaní alebo odstraňovaní tabletu z doku"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="3151046599205265919">"Neprehrávať zvuk pri vkladaní alebo odstraňovaní telefónu z doku"</string>
    <string name="account_settings" msgid="6403589284618783461">"Účty"</string>
    <string name="category_personal" msgid="1299663247844969448">"Osobné"</string>
    <string name="category_work" msgid="8699184680584175622">"Práca"</string>
    <string name="search_settings" msgid="1910951467596035063">"Hľadať"</string>
    <string name="search_settings_summary" msgid="9205656546570654169">"Správa nastavení a histórie vyhľadávaní"</string>
    <string name="display_settings" msgid="7965901687241669598">"Zobrazenie"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Automaticky otáčať obrazovku"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Pri otáčaní tabletu automaticky prepínať orientáciu"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Pri otáčaní telefónu automaticky prepínať orientáciu"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Pri otáčaní tabletu automaticky prepínať orientáciu"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Pri otáčaní telefónu automaticky prepínať orientáciu"</string>
    <string name="brightness" msgid="8480105032417444275">"Úroveň jasu"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Jas"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Nastavenia jasu obrazovky"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Prispôsobenie jasu"</string>
    <string name="auto_brightness_summary" msgid="1799041158760605375">"Optimalizovať úroveň jasu podľa dostupného svetla"</string>
    <string name="night_mode_title" msgid="6928425617491943384">"Motív"</string>
    <string name="night_mode_summary" msgid="9196605054622017193">"%s"</string>
    <string name="night_mode_no" msgid="7682792841791457238">"Svetlý"</string>
    <string name="night_mode_yes" msgid="4847655033618591567">"Tmavý"</string>
    <string name="night_mode_auto" msgid="7508348175804304327">"Automaticky"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Režim spánku"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"Vypnutie obrazovky"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"<xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> nečinnosti"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Tapeta"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Vybrať tapetu z"</string>
    <string name="screensaver_settings_title" msgid="3349790120327233241">"Šetrič obrazovky"</string>
    <string name="screensaver_settings_summary_either_long" msgid="2458481525925378465">"Pri vložení do doku alebo pri nabíjaní v režime spánku"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"V oboch prípadoch"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Pri nabíjaní"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Počas prítomnosti zariadenia v doku"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Vypnuté"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="3857507943322777651">"Ak chcete nastaviť, čo sa stane, keď je telefón v doku alebo v režime spánku, zapnite šetrič obrazovky."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8352267826043957746">"Kedy spustiť šetrič"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Spustiť"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Nastavenia"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Automatický jas"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Prebudiť zdvihnutím"</string>
    <string name="doze_title" msgid="2259176504273878294">"Ambientné zobrazenie"</string>
    <string name="doze_summary" msgid="7128970177894383698">"Zobudiť obrazovku pri zodvihnutí zariadenia alebo prijatí upozornení"</string>
    <string name="title_font_size" msgid="4405544325522105222">"Veľkosť písma"</string>
    <string name="dialog_title_font_size" msgid="2231507851258955038">"Veľkosť písma"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Nastavenia zámky karty SIM"</string>
    <string name="sim_lock_settings_category" msgid="5136244267576697004">"Nastavenia zámky karty SIM"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Zámka karty SIM"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Uzamykať kartu SIM"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Na použitie tabletu vyžadovať PIN"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Na použitie telefónu vyžadovať PIN"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Na použitie tabletu vyžadovať PIN"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Na použitie telefónu vyžadovať PIN"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Zmeniť PIN karty SIM"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"Kód PIN karty SIM"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Uzamykať kartu SIM"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Odomknúť kartu SIM"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Starý kód PIN karty SIM"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Nový kód PIN karty SIM"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Potvrďte nový kód PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"Kód PIN karty SIM"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Nesprávny kód PIN"</string>
    <string name="sim_pins_dont_match" msgid="8449681619822460312">"Kódy PIN sa nezhodujú"</string>
    <string name="sim_change_failed" msgid="304964924772218382">"Kód PIN nie je možné zmeniť.\nKód PIN je zrejme nesprávny."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"Kód PIN karty SIM bol zmenený."</string>
    <string name="sim_lock_failed" msgid="5651596916127873626">"Stav zámku karty SIM nie je možné zmeniť.\nZrejme ste zadali nesprávny kód PIN."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"OK"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Zrušiť"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"Našlo sa viacero SIM kariet"</string>
    <string name="sim_multi_sims_summary" msgid="7018740080801483990">"Vyberte SIM kartu preferovanú pre mobilné dátové prenosy."</string>
    <string name="sim_change_data_title" msgid="294357201685244532">"Zmeniť SIM kartu pre dáta?"</string>
    <string name="sim_change_data_message" msgid="1313940695939674633">"Používať pre mobilné dáta kartu <xliff:g id="NEW_SIM">%1$s</xliff:g> namiesto <xliff:g id="OLD_SIM">%2$s</xliff:g>?"</string>
    <string name="sim_preferred_title" msgid="5567909634636045268">"Aktualizovať pref. SIM kartu?"</string>
    <string name="sim_preferred_message" msgid="301251431163650167">"<xliff:g id="NEW_SIM">%1$s</xliff:g> je jediná SIM karta vo vašom zariadení. Chcete použiť túto SIM kartu pre mobilné dáta, hovory a správy SMS?"</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"Nesprávny kód PIN karty SIM. Teraz musíte kontaktovať svojho operátora, aby vám odomkol zariadenie."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="1582398808893048097">
      <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="pin_failed" msgid="1848423634948587645">"Operácia kódu PIN karty SIM zlyhala!"</string>
    <string name="device_info_settings" product="tablet" msgid="1119755927536987178">"Stav tabletu"</string>
    <string name="device_info_settings" product="default" msgid="475872867864762157">"Stav telefónu"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Aktualizácie systému"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Verzia systému Android"</string>
    <string name="model_number" msgid="3765737700545384794">"Číslo modelu"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"ID zariadenia"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Verzia základného pásma"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Verzia jadra"</string>
    <string name="build_number" msgid="3075795840572241758">"Číslo zostavy"</string>
    <string name="selinux_status" msgid="6212165375172061672">"Stav zabezpečenia SELinux"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Nie je k dispozícii"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Stav"</string>
    <string name="device_status" msgid="607405385799807324">"Stav"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Stav batérie, siete a ďalšie informácie"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Telefónne číslo, signál atď."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Úložisko"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Nastavenia ukladacieho priestoru"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Odpojiť ukladací priestor USB a zobraziť dostupný ukladací priestor"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Umožňuje odpojiť kartu SD a zobraziť dostupný ukladací priestor"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5123197324870153205">"Moje telefónne číslo"</string>
    <string name="status_min_number" msgid="3519504522179420597">"Min."</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"Verzia PRL"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_network_type" msgid="952552009117455166">"Typ mobilnej siete"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Informácie o operátorovi"</string>
    <string name="status_data_state" msgid="4578972321533789767">"Stav mobilnej siete"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Stav služby"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Sila signálu"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Roaming"</string>
    <string name="status_operator" msgid="2274875196954742087">"Sieť"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"Adresa MAC siete Wi-Fi"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Adresa zariadenia Bluetooth"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Sériové číslo"</string>
    <string name="status_unavailable" msgid="7862009036663793314">"Nie sú k dispozícii"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Doba prevádzky"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Doba prevádzky"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Interný ukl. priestor"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"Ukladací priestor USB"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"Karta SD"</string>
    <string name="memory_available" msgid="5052397223077021181">"K dispozícii"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"K dispozícii (len na čítanie)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Celková pamäť"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Prebieha výpočet..."</string>
    <string name="memory_apps_usage" msgid="2348501997988663688">"Aplikácie (údaje aplikácií a obsah médií)"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Médiá"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Stiahnutia"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Obrázky, videá"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Zvuk (hudba, vyzváňacie tóny, podcasty atď.)"</string>
    <string name="memory_media_misc_usage" msgid="235452944021647124">"Rôzne"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Údaje uložené vo vyrovnávacej pamäti"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Odpojte zdieľaný ukl. priestor"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Odpojiť kartu SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Odp. interný ukl. priestor USB"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Kvôli bezpečnému odstráneniu karty SD musíte kartu najprv odpojiť"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Vložte ukl. priestor USB na pripoj."</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Vložte kartu SD, ktorú chcete pripojiť"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Pripoj. ukl. priestor USB"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Pripojiť kartu SD"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Vymazať ukladací priestor USB"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Vymazať kartu SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Vymaže vš. údaje v internom uklad. priestore USB, napr. hudbu alebo fotografie."</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Vymaže všetky údaje na karte SD, ako je hudba alebo fotografie"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Vymazať údaje vo vyrovnávacej pamäti?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Vymažú sa údaje v pamäti pre všetky aplikácie"</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"Funkcia MTP alebo PTP je aktívna"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Odpojiť úložisko USB?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Odpojiť kartu SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"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="6998379994779187692">"Ak odpojíte kartu SD, niektoré používané aplikácie môžu byť zastavené a nebudú k dispozícii, kým kartu SD znova nepripojíte."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="4346280469528260684">"Úložisko USB sa nepodarilo odpojiť. Skúste to znova neskôr."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3073562815631781894">"Kartu SD sa nepodarilo odpojiť. Skúste to znova neskôr."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"Ukladací priestor USB bude odpojený."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"Karta SD bude odpojená."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Odpájanie"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Prebieha odpájanie"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Nedostatok ukladacieho priestoru"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"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_usb" msgid="5708207885333243384">"Pripojenie USB k počítaču"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Pripojenie USB k počítaču"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Pripojiť ako"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Zariadenie pre médiá (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"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="3852760810622389620">"Fotoaparát (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7673397474756664929">"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="3069990264258413994">"MIDI"</string>
    <string name="usb_midi_summary" msgid="539169474810956358">"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="808708845102611856">"Ďalší používatelia"</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Stav batérie"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Stav batérie"</string>
    <string name="apn_settings" msgid="3743170484827528406">"Názvy prístupových bodov (APN)"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Upraviť prístupový bod"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Nenastavené"</string>
    <string name="apn_name" msgid="4115580098369824123">"Meno"</string>
    <string name="apn_apn" msgid="2479425126733513353">"Názov prístupového bodu (APN)"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Server proxy"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Port"</string>
    <string name="apn_user" msgid="455637547356117761">"Používateľské meno"</string>
    <string name="apn_password" msgid="5412301994998250968">"Heslo"</string>
    <string name="apn_server" msgid="2436185314756372858">"Server"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"Server proxy systému MMS"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"Port systému MMS"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Typ overenia"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Žiadne"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP alebo CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Typ názvu prístupového bodu (APN)"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"Protokol APN"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protokol názvu prístupového bodu (APN) pre roaming"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Povoliť / zakázať názov prístupového bodu (APN)"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"Názov prístupového bodu (APN) je povolený"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"Názov prístupového bodu (APN) je zakázaný"</string>
    <string name="bearer" msgid="594270280031923558">"Operátor"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Typ MVNO"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Hodnota MVNO"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Odstrániť názov prístupového bodu (APN)"</string>
    <string name="menu_new" msgid="3014205883303921729">"Nový názov prístupového bodu (APN)"</string>
    <string name="menu_save" msgid="8109345640668285399">"Uložiť"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Zahodiť"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="8418502878620394756">"Pole Meno nemôže byť prázdne."</string>
    <string name="error_apn_empty" msgid="6056233831214537267">"Názov prístupového bodu (APN) nemôže byť prázdny."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"Pole MCC musí obsahovať aspoň 3 číslice."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Pole MNC musí obsahovať 2 alebo 3 číslice."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Prebieha obnovovanie predvolených nastavení názvu prístupového bodu (APN)."</string>
    <string name="menu_restore" msgid="8260067415075573273">"Obnoviť predvolené"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Obnovenie predvolených nastavení názvu prístupového bodu (APN) bolo dokončené."</string>
    <string name="device_reset_title" msgid="2384019005638768076">"Obnoviť zariadenie"</string>
    <string name="master_clear_title" msgid="5907939616087039756">"Obnovenie továrenských nastavení"</string>
    <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Vymaže všetky údaje v tablete"</string>
    <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Vymaže všetky údaje v telefóne"</string>
    <string name="master_clear_desc" product="tablet" msgid="8317211882509025841">"Táto operácia vymaže všetky údaje v "<b>"internom úložisku"</b>" tabletu, vrátane:\n\n"<li>"účtu Google"</li>\n<li>"údajov a nastavení systému a aplikácií"</li>\n<li>"prevzatých aplikácií"</li></string>
    <string name="master_clear_desc" product="default" msgid="9165016501623540228">"Táto operácia vymaže všetky údaje v "<b>"internom úložisku"</b>" telefónu, vrátane:\n\n"<li>"účtu Google"</li>\n<li>"údajov a nastavení systému a aplikácií"</li>\n<li>"prevzatých aplikácií"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Aktuálne ste prihlásení do nasledujúcich účtov:\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="5161423070702470742">\n\n"Na tomto zariadení sú prítomní ďalší používatelia.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Hudba"</li>\n<li>"Fotografie"</li>\n<li>"Iné používateľské údaje"</li></string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Ak chcete vymazať hudbu, obrázky a ďalšie používateľské údaje, musíte vymazať "<b>"úložisko USB"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Ak chcete vymazať hudbu, obrázky a ďalšie používateľské údaje, musíte vymazať "<b>"kartu SD"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Vymazať ukladací priestor USB"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Vymazať kartu SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Vymazať všetky údaje v internom úložisku USB (napr. hudbu a fotografie)"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Vymazať všetky údaje na karte SD (napr. hudbu alebo fotografie)"</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Obnoviť tablet"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Obnoviť telefón"</string>
    <string name="master_clear_final_desc" msgid="7209547812233487345">"Chcete vymazať všetky osobné údaje a stiahnuté aplikácie? Túto akciu nebude možné vrátiť späť."</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Vymazať všetko"</string>
    <string name="master_clear_gesture_explanation" msgid="826193821455182780">"Obnovenie továrenských nastavení musíte potvrdiť nakreslením bezpečnostného vzoru."</string>
    <string name="master_clear_failed" msgid="7959646179737950703">"Pokus o obnovenie sa neuskutočnil, pretože služba System Clear nie je k dispozícii."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Obnoviť?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Obnovenie továrenských nastavení nie je dostupné pre tohto používateľa"</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Prebieha vymazávanie"</string>
    <string name="master_clear_progress_text" msgid="6559096229480527510">"Čakajte..."</string>
    <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Vymazať ukladací priestor USB"</string>
    <string name="media_format_title" product="default" msgid="4427528440306787972">"Vymazať kartu SD"</string>
    <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Vymaže údaje v ukl. priestore USB"</string>
    <string name="media_format_summary" product="default" msgid="3805714639375830120">"Vymaže všetky údaje na karte SD"</string>
    <string name="media_format_desc" product="nosdcard" msgid="4557243156946319034">"Vymazať úložisko USB? Stratíte "<b>"všetky"</b>" uložené údaje!"</string>
    <string name="media_format_desc" product="default" msgid="8764037252319942415">"Vymazať kartu SD? Stratíte "<b>"všetky"</b>" údaje na karte!"</string>
    <string name="media_format_button_text" product="nosdcard" msgid="6293669371185352810">"Vymazať ukladací priestor USB"</string>
    <string name="media_format_button_text" product="default" msgid="6721544380069373626">"Vymazať kartu SD"</string>
    <string name="media_format_final_desc" product="nosdcard" msgid="699929778486375913">"Chcete úložisko USB vymazať a odstrániť tak všetky súbory, ktoré sú na ňom uložené? Túto akciu nebude možné vrátiť späť."</string>
    <string name="media_format_final_desc" product="default" msgid="3344525419872744989">"Chcete kartu SD vymazať a odstrániť tak všetky súbory, ktoré sú na nej uložené? Túto akciu nebude možné vrátiť späť."</string>
    <string name="media_format_final_button_text" msgid="4881713344315923175">"Odstrániť všetko"</string>
    <string name="media_format_gesture_explanation" product="nosdcard" msgid="2192044794228379224">"Vymazanie úložiska USB musíte potvrdiť nakreslením bezpečnostného vzoru."</string>
    <string name="media_format_gesture_explanation" product="default" msgid="6288926293245938415">"Vymazanie karty SD musíte potvrdiť nakreslením bezpečnostného vzoru."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Nastavenia hovorov"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Nastavenie hlasovej schránky, presmerovania hovorov, čakajúcich hovorov a identifikácie volajúceho"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Tethering cez USB"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Prenosný prístupový bod"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Pripojenie cez Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Zdieľanie dát. pripojenia"</string>
    <string name="tether_settings_title_all" msgid="8356136101061143841">"Zdieľ. dát. pripojenia a prenosný príst. bod"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Zdieľané dátové pripojenie prostredníctvom portu USB"</string>
    <string name="usb_tethering_available_subtext" msgid="156779271296152605">"Pripojenie USB je k dispozícii. Ak chcete vytvoriť zdieľané dátové prepojenie, vyberte ho."</string>
    <string name="usb_tethering_active_subtext" msgid="8916210851136467042">"Zdieľané dátové pripojenie"</string>
    <string name="usb_tethering_storage_active_subtext" msgid="5210094834194907094">"Internetové pripojenie nie je možné zdieľať, pokiaľ sa používa úložisko USB"</string>
    <string name="usb_tethering_unavailable_subtext" msgid="1044622421184007254">"Pripojenie USB nie je k dispozícii"</string>
    <string name="usb_tethering_turnon_subtext" msgid="4748616058219273033">"Ak chcete úložisko USB zapnúť, pripojte ho"</string>
    <string name="usb_tethering_errored_subtext" msgid="1377574819427841992">"Chyba zdieľania dátového pripojenia prostredníctvom USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Pripojenie cez Bluetooth"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="8811610320942954709">"Zdieľa internetové pripojenie tohto tabletu"</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="4229220575771946723">"Zdieľa internetové pripojenie tohto telefónu"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="2730938191906597896">"Internetové pripojenie tabletu zdieľa jedno zariadenie"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="1666736165420290466">"Internetové pripojenie telefónu zdieľa jedno zariadenie"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="1180765608259580143">"Zariadenia zdieľajúce internetové pripojenie tabletu (<xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g>)"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="8248942539362173005">"Zariadenia zdieľajúce internetové pripojenie telefónu: <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="1790242032929221788">"Zdieľa sa internetové pripojenie zariadenia <xliff:g id="DEVICE_NAME">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="2093881379028235555">"Nezdieľa internetové pripojenie tohto tabletu"</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="706860924389041342">"Nezdieľa internetové pripojenie tohto telefónu"</string>
    <string name="bluetooth_tethering_errored_subtext" msgid="4926566308991142264">"Internetové pripojenie nie je zdieľané"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="6285122039489881969">"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="2871192409329334813">"Ukončí sa zdieľané dát. pripojenie zariad. <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Pomocník"</string>
    <string name="network_settings_title" msgid="4871233236744292831">"Mobilné siete"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Mobilný plán"</string>
    <string name="sms_application_title" msgid="6134351177937015839">"Predvolená aplikácia SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Zmeniť aplikáciu na SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"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="602683880284921998">"Použiť aplikáciu <xliff:g id="NEW_APP">%s</xliff:g> ako aplikáciu pre SMS?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"Zmeniť aplikáciu asistent pripojenia Wi-Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"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="7444620909047611601">"Chcete spravovať sieťové pripojenia pomocou aplikácie <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Neznámy operátor SIM karty"</string>
    <string name="mobile_no_provisioning_url" msgid="2399426808423775711">"%1$s nemá žiadne provízne webové stránky"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Vložte kartu SIM a reštartujte"</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Pripojte sa k internetu"</string>
    <string name="location_title" msgid="1029961368397484576">"Moja poloha"</string>
    <string name="managed_profile_location_category" msgid="6992546457880004735">"Pracovný profil"</string>
    <string name="managed_profile_location_switch_title" msgid="6712332547063039683">"Poloha pre pracovný profil"</string>
    <string name="managed_profile_location_switch_lockdown" msgid="3851708343340350369">"Deaktivovala vaša spoločnosť"</string>
    <string name="location_mode_title" msgid="3982009713118421689">"Režim"</string>
    <string name="location_mode_high_accuracy_title" msgid="8241802585110932849">"Vysoká presnosť"</string>
    <string name="location_mode_battery_saving_title" msgid="711273645208158637">"Úspora batérie"</string>
    <string name="location_mode_sensors_only_title" msgid="3040366132175435160">"Len senzory zariadenia"</string>
    <string name="location_mode_location_off_title" msgid="2829713015012529465">"Poloha je vypnutá"</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Nedávne žiadosti o polohu"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"V poslednom čase žiadne aplikácie o polohu nepožiadali"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Služby určovania polohy"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Vysoká spotreba batérie"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Nízka spotreba batérie"</string>
    <string name="location_mode_screen_title" msgid="4528716772270246542">"Režim určovania polohy"</string>
    <string name="location_mode_high_accuracy_description" msgid="5349014493087338351">"Na určenie polohy používať technológiu GPS, sieť Wi-Fi a mobilné siete"</string>
    <string name="location_mode_battery_saving_description" msgid="7581657383062066461">"Na určenie polohy používať sieť Wi-Fi a mobilné siete"</string>
    <string name="location_mode_sensors_only_description" msgid="788127681455735699">"Určovať polohu pomocou GPS"</string>
    <string name="location_network_based" msgid="6010456018401296590">"Urč. polohy pomocou Wi-Fi a mobil. siete"</string>
    <string name="location_neighborhood_level" msgid="5626515380188353712">"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="4234820941954812210">"Poloha je určená podľa siete Wi-Fi"</string>
    <string name="location_gps" msgid="8392461023569708478">"Satelity GPS"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Umožniť aplikáciám na vašom tablete určovať polohu pomocou GPS"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Umožniť aplikáciám na vašom telefóne určovať polohu pomocou GPS"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Použiť systém A-GPS"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Vylepšiť funkčnosť GPS pomocou servera (vypnutím tejto funkcie znížite využitie siete)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Vylepšiť funkčnosť GPS pomocou servera (zrušením tejto funkcie zvýšite výkon GPS)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Poloha a vyhľadávanie Google"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"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="7064108942964081243">"Prístup k údajom o mojej polohe"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Umožniť aplikáciám, ktoré o to požiadali, používať údaje o polohe"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Zdroje polohy"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"Informácie o tablete"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"Informácie o telefóne"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Zobrazuje právne informácie, stav a verziu softvéru"</string>
    <string name="legal_information" msgid="5769301644270604095">"Právne informácie"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Prispievatelia"</string>
    <string name="regulatory_information" msgid="5695464367088752150">"Regulačné informácie"</string>
    <string name="copyright_title" msgid="865906688917260647">"Autorské práva"</string>
    <string name="license_title" msgid="1990487604356037871">"Licencia"</string>
    <string name="terms_title" msgid="7697580845616764642">"Zmluvné podmienky"</string>
    <string name="webview_license_title" msgid="2813507464175738967">"Licencia systému WebView"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Tapety"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Poskytovatelia satelitných snímok:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_license_activity_title" msgid="7553683406244228650">"Licencie otvoreného zdroja"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Pri načítavaní licencií sa vyskytla chyba."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Prebieha načítavanie…"</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Bezpečnostné informácie"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Bezpečnostné informácie"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="232523852222964470">"Nemáte dátové pripojenie. Ak chcete tieto informácie zobraziť teraz, prejdite v ľubovoľnom počítači pripojenom na Internet na adresu %s."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Prebieha načítavanie…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Zvoľte heslo"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="6949761069941694050">"Voľba vzoru"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Zvoľte kód PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6308478184889846633">"Potvrďte heslo"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Potvrdenie vzoru"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="49038294648213197">"Potvrďte kód PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="6850677112663979120">"Heslá sa nezhodujú"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="4757532830594400147">"Kódy PIN nie sú zhodné"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Spôsob odomknutia"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Heslo bolo nastavené"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"Bol nastavený kód PIN"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Vzor bol nastavený"</string>
    <string name="lock_settings_title" msgid="335025124489630932">"Zabezpečenie obrazovky"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Zmena bezpečnostného vzoru"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Zmena bezpečnostného kódu PIN"</string>
    <string name="lockpattern_need_to_unlock" msgid="757935356911054465">"Potvrďte uložený vzor"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="4694973540770105678">"Skúste to znova"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Nakreslite bezpečnostný vzor"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Pomocníka zobrazíte stlačením klávesy Menu."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Na záver zdvihnite prst z obrazovky"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Minimálny počet spojených bodov je <xliff:g id="NUMBER">%d</xliff:g>. Skúste to znova."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Vzor bol zaznamenaný"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Znovu nakreslite pre potvrdenie"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Nový bezpečnostný vzor"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Potvrdiť"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Nakresliť znova"</string>
    <string name="lockpattern_retry_button_text" msgid="1949847413862309134">"Skúsiť znova"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Pokračovať"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Bezpečnostný vzor"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Vyžadovať vzor"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Obrazovku musíte odomknúť nakreslením bezpečnostného vzoru."</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Zobrazovať vzor"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="8898518337442601027">"Vibrovanie pri dotyku"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Zamknúť tlačidlom napájania"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"Ak odomknutie nie je udržované funkciou <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Nastaviť bezpečnostný vzor"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Zmena bezpečnostného vzoru"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Bezpečnostný vzor obrazovky nakreslite takto"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_header" msgid="819903817323783498">"Príliš veľa chybných pokusov."</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_footer" msgid="6759029360597122873">"Počet sekúnd zostávajúcich do ďalšieho pokusu: <xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Aplikácia nie je v telefóne nainštalovaná."</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Spravovať aplikácie"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Správa a odstraňovanie nainštalovaných aplikácií"</string>
    <string name="applications_settings" msgid="1721442176406964682">"Aplikácie"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Správa aplikácií a nastavenie rýchleho spustenia"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Nastavenia aplikácie"</string>
    <string name="install_applications" msgid="4872012136210802181">"Neznáme zdroje"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Povoliť všet. zdroje aplikácií"</string>
    <string name="install_unknown_applications_title" msgid="663831043139080992">"Umožňuje inštalovať aplikácie z iných zdrojov ako sl. Google Play"</string>
    <string name="install_unknown_applications" msgid="176855644862942064">"Povoliť inštaláciu aplikácií z neznámych zdrojov"</string>
    <string name="install_all_warning" product="tablet" msgid="3263360446508268880">"Váš tablet a osobné údaje sú zraniteľnejšie voči útokom aplikácií z neznámych zdrojov. Súhlasíte s tým, že nesiete výhradnú zodpovednosť za všetky škody na tablete alebo stratu údajov, ktoré môžu vzniknúť v dôsledku používania týchto aplikácií."</string>
    <string name="install_all_warning" product="default" msgid="8113734576826384682">"Váš telefón a osobné údaje sú zraniteľnejšie voči útokom aplikácií z neznámych zdrojov. Súhlasíte s tým, že nesiete výhradnú zodpovednosť za všetky škody na telefóne alebo stratu údajov, ktoré môžu vzniknúť v dôsledku používania týchto aplikácií."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Rozšírené nastavenia"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Povoliť ďalšie možnosti nastavení"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Informácie o aplikácii"</string>
    <string name="storage_label" msgid="8700867073480107253">"Úložisko"</string>
    <string name="auto_launch_label" msgid="3012617472833815382">"Spúšťať ako predvolenú"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Predvolené"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Kompatibilita obrazovky"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Povolenia"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Vyrovnávacia pamäť"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Vymazať vyrovnávaciu pamäť"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Vyrovnávacia pamäť"</string>
    <string name="controls_label" msgid="7611113077086853799">"Ovládacie prvky"</string>
    <string name="force_stop" msgid="7435006169872876756">"Vynútiť zastavenie"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Celkom"</string>
    <string name="application_size_label" msgid="8494609207373874267">"Aplikácia"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Aplikácia ukladací priestor USB"</string>
    <string name="data_size_label" msgid="8679376373625710107">"Údaje"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Údaje ukladacieho priestoru USB"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"Karta SD"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Odinštalovať"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Odinštalovať pre všetkých používateľov"</string>
    <string name="install_text" msgid="884360662922471113">"Inštalovať"</string>
    <string name="disable_text" msgid="6544054052049395202">"Zakázať"</string>
    <string name="enable_text" msgid="9217362512327828987">"Povoliť"</string>
    <string name="clear_user_data_text" msgid="5597622864770098388">"Vymazať údaje"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Odinštalovať aktualizácie"</string>
    <string name="auto_launch_enable_text" msgid="2652825923953591251">"Pre niektoré akcie ste sa rozhodli spúšťať túto aplikáciu ako predvolenú."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="3368654672141202604">"Tejto aplikácii ste povolili vytváranie miniaplikácií a pristupovanie k ich údajom."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Nie je predvolená pre žiadne akcie."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Vymazať predvolené nastavenia"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"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="7225195569089607846">"Opýtať sa pri spustení"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Prispôsobiť veľkosť aplikácie"</string>
    <string name="unknown" msgid="1592123443519355854">"Neznáme"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Zoradiť podľa názvu"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Zoradiť podľa veľkosti"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Ukázať spustené služby"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Procesy vo vyrov. pamäti"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Obnoviť predvoľby aplik."</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Obnoviť predvoľby aplik.?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"Táto akcia obnoví predvoľby pre:\n\n "<li>"zakázané aplikácie,"</li>\n" "<li>"upozornenia zakázaných aplikácií,"</li>\n" "<li>"predvolené aplikácie pre akcie,"</li>\n" "<li>"obmedzenia údajov v pozadí pre aplikácie,"</li>\n" "<li>"akékoľvek obmedzenia povolení."</li>\n\n" Nestratíte žiadne údaje aplikácií."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Obnoviť aplikácie"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Správa pamäte"</string>
    <string name="filter" msgid="2018011724373033887">"Filtrovať"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Zvoľte možnosti filtra"</string>
    <string name="filter_apps_all" msgid="5142129378749391876">"Všetko"</string>
    <string name="filter_apps_disabled" msgid="5364447573326472890">"Zakázané"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Stiahnuté"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Spustené"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Ukladací priestor USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Na karte SD"</string>
    <string name="disabled" msgid="9206776641295849915">"Zakázané"</string>
    <string name="not_installed" msgid="2797554494953450291">"Pre tohto používateľa nenainš."</string>
    <string name="no_applications" msgid="7336588977497084921">"Žiadne aplikácie."</string>
    <string name="internal_storage" msgid="1584700623164275282">"Interný ukl. priestor"</string>
    <string name="sd_card_storage" product="nosdcard" msgid="2673203150465132465">"Ukladací priestor USB"</string>
    <string name="sd_card_storage" product="default" msgid="7623513618171928235">"Ukl. priestor karty SD"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Prebieha prepočítanie veľkosti..."</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Odstrániť údaje aplikácie?"</string>
    <string name="clear_data_dlg_text" msgid="8847257251846779938">"Všetky údaje tejto aplikácie (súbory, nastavenia, účty, databázy atď.) budú navždy odstránené."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"OK"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Zrušiť"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="8333723538280257243">"Aplikáciu sa nepodarilo nájsť v zozname nainštalovaných aplikácií."</string>
    <string name="clear_data_failed" msgid="1907582169616856698">"Údaje aplikácie sa nepodarilo vymazať."</string>
    <string name="app_factory_reset_dlg_title" msgid="7441012826373143593">"Odinštalovať aktualizácie?"</string>
    <string name="app_factory_reset_dlg_text" msgid="6371247225487725860">"Všetky aktualizácie tejto systémovej aplikácie systému Android budú odinštalované."</string>
    <string name="clear_failed_dlg_title" msgid="2387060805294783175">"Vymazať údaje"</string>
    <string name="clear_failed_dlg_text" msgid="1092177570631523106">"Údaje aplikácie sa nepodarilo vymazať."</string>
    <string name="security_settings_desc" product="tablet" msgid="1292421279262430109">"Táto aplikácia môže pristupovať k nasledujúcim funkciám tabletu:"</string>
    <string name="security_settings_desc" product="default" msgid="61749028818785244">"Táto aplikácia môže pristupovať k nasledujúcim funkciám telefónu:"</string>
    <string name="security_settings_desc_multi" product="tablet" msgid="7300932212437084403">"Táto aplikácia môže pristupovať k nasledujúcim aplikáciám v tablete. Niektoré z týchto povolení sú s cieľom zlepšenia výkonu a zníženia využívania pamäte k dispozícii aj pre aplikáciu <xliff:g id="BASE_APP_NAME">%1$s</xliff:g>, ktorá sa spúšťa v rámci rovnakého procesu ako aplikácia <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="security_settings_desc_multi" product="default" msgid="6610268420793984752">"Táto aplikácia môže pristupovať k nasledujúcim aplikáciám v telefóne. Niektoré z týchto povolení sú s cieľom zlepšenia výkonu a zníženia využívania pamäte k dispozícii aj pre aplikáciu <xliff:g id="BASE_APP_NAME">%1$s</xliff:g>, ktorá sa spúšťa v rámci rovnakého procesu ako aplikácia <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> a <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="5925635036718502724">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> a <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="4333907712038448660">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="7556692394478220814">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="security_settings_billing_desc" msgid="8061019011821282358">"Táto aplikácia vám môže účtovať poplatky:"</string>
    <string name="security_settings_premium_sms_desc" msgid="8734171334263713717">"Odoslať prémiovú správu SMS"</string>
    <string name="computing_size" msgid="1599186977475211186">"Prebieha výpočet…"</string>
    <string name="invalid_size_value" msgid="7563537715280712285">"Nepodarilo sa vypočítať veľkosť balíčka."</string>
    <string name="empty_list_msg" msgid="5993162337235907160">"Nie sú nainštalované žiadne aplikácie tretích strán."</string>
    <string name="version_text" msgid="9189073826278676425">"verzia <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Presunúť"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Presunúť do tabletu"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Presunúť do telefónu"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Presun. do ukl. priestoru USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Presunúť na kartu SD"</string>
    <string name="moving" msgid="6431016143218876491">"Presúvanie"</string>
    <string name="insufficient_storage" msgid="481763122991093080">"V úložisku nie je dostatok miesta."</string>
    <string name="does_not_exist" msgid="3476487214886606748">"Aplikácia neexistuje."</string>
    <string name="app_forward_locked" msgid="6331564656683790866">"Aplikácia je chránená proti kopírovaniu."</string>
    <string name="invalid_location" msgid="2786030127356312746">"Umiestnenie inštalácie nie je platné."</string>
    <string name="system_package" msgid="6222593098063037137">"Aktualizácie systému sa nepodarilo nainštalovať na externé médiá."</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Vynútiť zastavenie?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Ak vynútite zastavenie aplikácie, môže sa správať zvláštne."</string>
    <string name="move_app_failed_dlg_title" msgid="1282561064082384192"></string>
    <string name="move_app_failed_dlg_text" msgid="3465267182923054022">"Aplikáciu sa nepodarilo presunúť. <xliff:g id="REASON">%1$s</xliff:g>"</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Preferované umiestnenie pre inštaláciu"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Zmena preferovaného umiestnenia pre inštaláciu nových aplikácií"</string>
    <string name="app_disable_dlg_title" msgid="3916469657537695436">"Zakázať vstavanú aplikáciu?"</string>
    <string name="app_disable_dlg_text" msgid="3562567756362627323">"Ak zakážete vstavané aplikácie, ostatné aplikácie sa môžu správať zvláštne."</string>
    <string name="app_special_disable_dlg_title" msgid="2690148680327142674">"Odstrániť údaje a zakázať aplikáciu?"</string>
    <string name="app_special_disable_dlg_text" msgid="3447657419284854195">"Ak zakážete vstavanú aplikáciu, ostatné aplikácie nemusia fungovať správne. Vaše údaje sa taktiež odstránia."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Vypnúť upozornenia?"</string>
    <string name="app_disable_notifications_dlg_text" msgid="5088484670924769845">"Ak v tejto aplikácii vypnete upozornenia, môžete prísť o dôležité upozornenia a aktuálne informácie."</string>
    <string name="app_ops_settings" msgid="5108481883575527511">"Fungovanie aplikácií"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"Spustené"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Nikdy nepoužité)"</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Využitie ukl. priestoru"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Zobraziť úložisko používané aplikáciami"</string>
    <string name="runningservices_settings_title" msgid="8097287939865165213">"Spustené služby"</string>
    <string name="runningservices_settings_summary" msgid="854608995821032748">"Zobrazenie a ovládanie aktuálne spustených služieb"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Prebieha reštartovanie"</string>
    <string name="cached" msgid="1059590879740175019">"Proces na pozadí vo vyrovnávacej pamäti"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Nič nie je spustené."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Spustené aplikáciou."</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> voľnej"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"Využité: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Používateľ: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Odstránený používateľ"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"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="8019860457123222953">"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="744424668287252915">"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="1607384595790852782">"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="6588371727640789560">"Pamäť zariadenia"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Využitie pamäte RAM (aplikácia)"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Systém"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Aplikácie"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"Voľné"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Použité"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"V pamäti"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"RAM: <xliff:g id="RAM_0">%1$s</xliff:g>"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Spustená aplikácia"</string>
    <string name="no_services" msgid="7133900764462288263">"Neaktívne"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Služby"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Procesy"</string>
    <string name="service_stop" msgid="6369807553277527248">"Zastaviť"</string>
    <string name="service_manage" msgid="1876642087421959194">"Nastavenia"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"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="2979218727598321095">"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="5034773197139654588">"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="7050092269951613102">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: práve sa používa. Ovládacie prvky zobrazte dotykom na Nastavenia."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Hlavný proces, ktorý sa používa."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Služba <xliff:g id="COMP_NAME">%1$s</xliff:g> sa používa."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Poskytovateľ <xliff:g id="COMP_NAME">%1$s</xliff:g> sa používa."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Zastaviť systémovú službu?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"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="3920243762189484756">"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_settings" msgid="5292716747264442359">"Jazyk &amp; vstup"</string>
    <string name="language_keyboard_settings_title" msgid="243220021717425813">"Jazyk &amp; vstup"</string>
    <string name="language_settings_category" msgid="2288258489940617043">"Jazykové nastavenia"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Klávesnica a metódy vstupu"</string>
    <string name="phone_language" msgid="8870144109924299673">"Jazyk"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Automatické nahradenie"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Opravovať pravopisné chyby"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Veľké písmená automaticky"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Prvé písmeno vo vete je automaticky veľké"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Automatická interpunkcia"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Nastavenia fyzickej klávesnice"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Znak „.“ môžete vložiť dvojitým stlačením klávesu Medzerník."</string>
    <string name="show_password" msgid="3001113966880559611">"Zobrazovať heslá"</string>
    <string name="ime_security_warning" msgid="4135828934735934248">"Pri metóde vstupu je možné zhromažďovať zadávaný text vrátane osobných údajov, ako sú napríklad heslá alebo čísla kreditných kariet. Tento spôsob je používaný aplikáciou <xliff:g id="IME_APPLICATION_NAME">%1$s</xliff:g>. Chcete použiť túto metódu vstupu?"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"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="246728645150092058">"Nastavenia"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Jazyk"</string>
    <string name="failed_to_open_app_settings_toast" msgid="1251067459298072462">"Nastavenia aplikácie <xliff:g id="SPELL_APPLICATION_NAME">%1$s</xliff:g> sa nepodarilo otvoriť"</string>
    <string name="pointer_settings_category" msgid="8183819795164034286">"Myš/trackpad"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Rýchlosť ukazovateľa"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Herné ovládače"</string>
    <string name="vibrate_input_devices" msgid="2599591466928793082">"Použiť vibrovanie"</string>
    <string name="vibrate_input_devices_summary" msgid="4595570516865299153">"Presmerovať vibrácie do herného ovládača, pokiaľ je pripojený."</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Zvoľte rozloženie klávesnice"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Nastaviť rozloženia klávesnice"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Prepnite klávesmi ctrl-space"</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Predvolené"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Rozloženia klávesnice"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Osobný slovník"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Pridať"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Pridať do slovníka"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Fráza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Viac možností"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Menej možností"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Slovo:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Skratka:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Jazyk:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Zadajte slovo"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Voliteľná skratka"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Upraviť slovo"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Upraviť"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Odstrániť"</string>
    <string name="user_dict_settings_empty_text" msgid="8165273379942105271">"V používateľskom slovníku nie sú žiadne slová. Slovo pridáte dotknutím sa tlačidla Pridať (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Pre všetky jazyky"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Ďalšie jazyky..."</string>
    <string name="testing" msgid="6584352735303604146">"Testovanie"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informácie o tablete"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Informácie o telefóne"</string>
    <string name="testing_battery_info" msgid="3497865525976497848">"Informácie o batérii"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Zadávanie textu"</string>
    <string name="input_method" msgid="5434026103176856164">"Metóda vstupu"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Aktuálna klávesnica"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Výber metódy vstupu"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automaticky"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Vždy zobrazovať"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Vždy skrývať"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Nastavenie metód vstupu"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Nastavenia"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Nastavenia"</string>
    <string name="active_input_method_subtypes" msgid="3596398805424733238">"Aktívne metódy vstupu"</string>
    <string name="use_system_language_to_select_input_method_subtypes" msgid="3346751753141428573">"Použiť jazyk systému"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Nastavenia <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Zvoliť aktívne metódy vstupu"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Nastavenia klávesnice na obrazovke"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Fyzická klávesnica"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Nastavenia fyzickej klávesnice"</string>
    <string name="development_settings_title" msgid="215179176067683667">"Možnosti pre vývojárov"</string>
    <string name="development_settings_summary" msgid="1815795401632854041">"Možnosti nastavenia vývoja aplikácií"</string>
    <string name="development_settings_not_available" msgid="4308569041701535607">"Pre tohto používateľa sú možnosti vývojára nedostupné"</string>
    <string name="vpn_settings_not_available" msgid="956841430176985598">"Nastavenia vzdialeného pripojenia VPN nie sú dostupné pre tohto používateľa"</string>
    <string name="tethering_settings_not_available" msgid="6765770438438291012">"Nastavenia zdieľania dátového pripojenia nie sú dostupné pre tohto používateľa"</string>
    <string name="apn_settings_not_available" msgid="7873729032165324000">"Nastavenia názvu prístupového bodu (APN) nie sú dostupné pre tohto používateľa"</string>
    <string name="enable_adb" msgid="7982306934419797485">"Ladenie USB"</string>
    <string name="enable_adb_summary" msgid="4881186971746056635">"Režim ladenia behom pripojenia cez USB"</string>
    <string name="clear_adb_keys" msgid="4038889221503122743">"Odvolanie autorizácií na ladenie USB"</string>
    <string name="bugreport_in_power" msgid="7923901846375587241">"Skratka hlásenia o chybe"</string>
    <string name="bugreport_in_power_summary" msgid="1778455732762984579">"Zobraziť tlačidlo vytvorenia hlásenia o chybe v hlavnej ponuke"</string>
    <string name="keep_screen_on" msgid="1146389631208760344">"Nevypínať obrazovku"</string>
    <string name="keep_screen_on_summary" msgid="2173114350754293009">"Obrazovka sa pri nabíjaní neprepne do režimu spánku"</string>
    <string name="bt_hci_snoop_log" msgid="3340699311158865670">"Povoliť sledovanie Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_summary" msgid="730247028210113851">"Zaznamenať všetky pakety Bluetooth HCI do súboru"</string>
    <string name="oem_unlock_enable" msgid="6040763321967327691">"Odblokovať OEM"</string>
    <string name="oem_unlock_enable_summary" msgid="4720281828891618376">"Povoliť odblokovanie ponuky bootloader"</string>
    <string name="oem_unlock_enable_pin_prompt" msgid="2398518281753145705">"Zadajte svoj kód PIN"</string>
    <string name="oem_unlock_enable_pin_description" msgid="1373634087885107329">"Ak chcete aktivovať odomknutie OEM, zadajte kód PIN zariadenia"</string>
    <string name="confirm_enable_oem_unlock_title" msgid="4802157344812385674">"Povoliť odblokovanie OEM?"</string>
    <string name="confirm_enable_oem_unlock_text" msgid="5517144575601647022">"UPOZORNENIE: V prípade, že bude toto nastavenie zapnuté, funkcie ochrany zariadenia nebudú na tomto zariadení fungovať."</string>
    <string name="wifi_display_certification" msgid="8611569543791307533">"Certifikácia bezdrôtového displeja"</string>
    <string name="wifi_verbose_logging" msgid="4203729756047242344">"Povoliť prihlasovanie Wi-Fi Verbose"</string>
    <string name="wifi_aggressive_handover" msgid="9194078645887480917">"Agres. odovzdávať Wi-Fi na mobilnú sieť"</string>
    <string name="wifi_allow_scan_with_traffic" msgid="3601853081178265786">"Vždy povoliť funkciu Wi-Fi Roam Scans"</string>
    <string name="wifi_display_certification_summary" msgid="1155182309166746973">"Zobraziť možnosti certifikácie bezdrôtového displeja"</string>
    <string name="wifi_verbose_logging_summary" msgid="6615071616111731958">"Zvýšiť úroveň prihlasov. do Wi-Fi, zobraziť na SSID RSSI v nástroji Wi-Fi Picker"</string>
    <string name="wifi_aggressive_handover_summary" msgid="6328455667642570371">"Keď túto možnosť povolíte, Wi-Fi bude s väčšou intenzitou odovzdávať dát. pripoj. na mob. sieť vtedy, keď bude slabý signál Wi-Fi"</string>
    <string name="wifi_allow_scan_with_traffic_summary" msgid="2575101424972686310">"Povoliť alebo zakázať funkciu Wifi Roam Scans na základe objemu prenosu údajov v rozhraní"</string>
    <string name="select_logd_size_title" msgid="7433137108348553508">"Veľkosti vyrovnávacej pamäte denníka"</string>
    <string name="select_logd_size_dialog_title" msgid="1206769310236476760">"Veľkosti den. na vyrov. pamäť den."</string>
    <string name="select_usb_configuration_title" msgid="2649938511506971843">"Vyberte konfiguráciu USB"</string>
    <string name="select_usb_configuration_dialog_title" msgid="6385564442851599963">"Vyberte konfiguráciu USB"</string>
    <string name="allow_mock_location" msgid="2787962564578664888">"Povoliť simulované polohy"</string>
    <string name="allow_mock_location_summary" msgid="317615105156345626">"Povoliť simulované polohy"</string>
    <string name="debug_view_attributes" msgid="6485448367803310384">"Povoliť kontrolu atribútov zobrazenia"</string>
    <string name="adb_warning_title" msgid="6234463310896563253">"Povoliť ladenie USB?"</string>
    <string name="adb_warning_message" msgid="7316799925425402244">"Ladenie prostredníctvom USB je určené iba na účely vývoja. Použite ho na kopírovanie dát medzi počítačom a zariadením, inštaláciu aplikácií do zariadenia bez upozornenia a čítanie údajov denníka."</string>
    <string name="adb_keys_warning_message" msgid="6932230298032192937">"Odvolať prístup k ladeniu USB zo všetkých počítačov, ktoré ste predtým autorizovali?"</string>
    <string name="dev_settings_warning_title" msgid="7244607768088540165">"Povoliť nastavenia pre vývojárov?"</string>
    <string name="dev_settings_warning_message" msgid="2298337781139097964">"Tieto nastavenia sú určené len pre vývojárov. Môžu spôsobiť poruchu alebo nesprávne fungovanie zariadenia a nainštalovaných aplikácií."</string>
    <string name="verify_apps_over_usb_title" msgid="4177086489869041953">"Overovať aplikácie z USB"</string>
    <string name="verify_apps_over_usb_summary" msgid="9164096969924529200">"Kontrolovať škodlivosť aplikácií nainštalovaných pomocou nástroja ADB/ADT"</string>
    <string name="enforce_read_external_title" product="nosdcard" msgid="7733257271454664956">"Chrániť úložisko USB"</string>
    <string name="enforce_read_external_summary" product="nosdcard" msgid="1798088409346660567">"Aplikácie musia pred čítaním z úložiska USB žiadať povolenie"</string>
    <string name="enforce_read_external_confirm_title" product="nosdcard" msgid="2112813067171502209">"Chrániť úložisko USB?"</string>
    <string name="enforce_read_external_confirm_message" product="nosdcard" msgid="605444326545922054">"Keď je úložisko USB chránené, aplikácie musia pred čítaním údajov z externého úložiska požiadať o povolenie.\n\nPri niektorých aplikáciách platí, že budú fungovať až vtedy, keď ich vývojári aktualizujú."</string>
    <string name="enforce_read_external_title" product="default" msgid="2226662853797940829">"Chrániť kartu SD"</string>
    <string name="enforce_read_external_summary" product="default" msgid="2750027486786530064">"Aplikácie musia pred čítaním z karty SD vyžiadať povolenie"</string>
    <string name="enforce_read_external_confirm_title" product="default" msgid="273220585729800783">"Chrániť kartu SD?"</string>
    <string name="enforce_read_external_confirm_message" product="default" msgid="3858482712337574407">"Keď je karta SD chránená, aplikácie musia pred čítaním údajov z externého úložiska požiadať o povolenie.\n\nPri niektorých aplikáciách platí, že budú fungovať až vtedy, keď ich vývojári aktualizujú."</string>
    <string name="enable_terminal_title" msgid="95572094356054120">"Miestny terminál"</string>
    <string name="enable_terminal_summary" msgid="67667852659359206">"Povoliť terminálovú apl. na miestny prístup k prostrediu shell"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Vyberte modul gadget"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Vyberte miniaplikáciu"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Vytvoriť miniaplikáciu a povoliť prístup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"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="7037503685859688034">"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="battery_history_days" msgid="7110262897769622564">"<xliff:g id="DAYS">%1$d</xliff:g> dní <xliff:g id="HOURS">%2$d</xliff:g> h <xliff:g id="MINUTES">%3$d</xliff:g> min <xliff:g id="SECONDS">%4$d</xliff:g> s"</string>
    <string name="battery_history_hours" msgid="7525170329826274999">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> min <xliff:g id="SECONDS">%3$d</xliff:g> s"</string>
    <string name="battery_history_minutes" msgid="1467775596084148610">"<xliff:g id="MINUTES">%1$d</xliff:g> min <xliff:g id="SECONDS">%2$d</xliff:g> s"</string>
    <string name="battery_history_seconds" msgid="4283492130945761685">"<xliff:g id="SECONDS">%1$d</xliff:g> s"</string>
    <string name="battery_history_days_no_seconds" msgid="703063770554334710">"<xliff:g id="DAYS">%1$d</xliff:g> d. <xliff:g id="HOURS">%2$d</xliff:g> hod. <xliff:g id="MINUTES">%3$d</xliff:g> min."</string>
    <string name="battery_history_hours_no_seconds" msgid="663342892615646712">"<xliff:g id="HOURS">%1$d</xliff:g> hod. <xliff:g id="MINUTES">%2$d</xliff:g> min."</string>
    <string name="battery_history_minutes_no_seconds" msgid="7780294302606853082">"<xliff:g id="MINUTES">%1$d</xliff:g> min."</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Štatistiky používania"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Štatistiky používania"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Zoradiť podľa:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplikácia"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Naposledy použité"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Doba použitia"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Uľahčenie prístupu"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Nastavenia uľahčenia prístupu"</string>
    <string name="accessibility_services_title" msgid="2592221829284342237">"Služby"</string>
    <string name="accessibility_system_title" msgid="7187919089874130484">"Systém"</string>
    <string name="accessibility_display_title" msgid="7610175687949675162">"Displej"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Titulky"</string>
    <string name="accessibility_screen_magnification_title" msgid="7001782548715744981">"Gestá priblíženia"</string>
    <string name="accessibility_screen_magnification_summary" msgid="2380627654189671754">"Keď je táto funkcia zapnutá, môžete približovať alebo odďalovať trojitým klepnutím na obrazovku.\n\nPočas priblíženia môžete:\n"<ul><li>"Posúvať: Ťahajte dvoma alebo viacerými prstami po obrazovke."</li>\n<li>"Prispôsobiť úroveň priblíženia: Priblížte dva alebo viacero prstov k sebe alebo ich od seba odtiahnite."</li></ul>\n\n"Obsah pod prstom môžete tiež dočasne priblížiť trojitým klepnutím a podržaním. V stave priblíženia môžete posúvaním prsta preskúmavať rôzne časti obrazovky. Odtiahnutím prsta sa vrátite do predchádzajúceho stavu.\n\nPoznámka: Priblíženie trojitým klepnutím funguje všade okrem klávesnice a navigačného panela."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="6752037184140789970">"Skratka uľahčenia prístupu"</string>
    <string name="accessibility_global_gesture_preference_summary_on" msgid="6180927399052022181">"Zapnuté"</string>
    <string name="accessibility_global_gesture_preference_summary_off" msgid="8102103337813609849">"Vypnuté"</string>
    <string name="accessibility_global_gesture_preference_description" msgid="750438015254396963">"Ak je táto funkcia zapnutá, môžete rýchlo v dvoch krokoch povoliť funkcie zjednodušenia ovládania:\n\nKrok 1: Stlačte tlačidlo zapnutia a podržte ho, dokým nezaznie zvukový signál alebo nezacítite vibrácie.\n\nKrok 2: Dotknite sa obrazovky dvoma prstami a podržte ju, dokým nezaznie zvuk potvrdenia.\n\nAk má zariadenie viacero používateľov, pomocou tejto skratky je možné na uzamknutej obrazovke dočasne povoliť zjednodušenie ovládania, dokým sa zariadenie neodomkne."</string>
    <string name="accessibility_toggle_large_text_preference_title" msgid="6307247527580207161">"Veľké písmo"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Text s vysokým kontrastom"</string>
    <string name="accessibility_toggle_screen_magnification_preference_title" msgid="2472285215737820469">"Priblíženie obrazovky"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Auto. aktualiz. priblíž. obrazovky"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Aktualizovať priblíž. obrazov. pri prechodoch apl."</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Tlačidlo Napájanie ukončuje hovor"</string>
    <string name="accessibility_toggle_speak_password_preference_title" msgid="5986628515113204844">"Hovorené heslá"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Oneskorenie dotyku a podržania"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Inverzia farieb"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="8658240868230680912">"(Experimentálne) Môže mať vplyv na výkonnosť"</string>
    <string name="accessibility_display_daltonizer_preference_title" msgid="5800761362678707872">"Úprava farieb"</string>
    <string name="accessibility_display_daltonizer_preference_subtitle" msgid="3484969015295282911">"Funkcia je experimentálna a môže mať vplyv na výkonnosť"</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Zobraziť v Rýchlych nastaveniach"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Režim korekcie"</string>
    <string name="daltonizer_type_overridden" msgid="3116947244410245916">"Prekonané predvoľbou <xliff:g id="TITLE">%1$s</xliff:g>"</string>
    <string name="daltonizer_mode_disabled" msgid="7482661936053801862">"Zakázané"</string>
    <string name="daltonizer_mode_monochromacy" msgid="8485709880666106721">"Monochromázia (úplna farbosleposť)"</string>
    <string name="daltonizer_mode_deuteranomaly" msgid="5475532989673586329">"Deuteranomália (červená-zelená)"</string>
    <string name="daltonizer_mode_protanomaly" msgid="8424148009038666065">"Protanomália (červená-zelená)"</string>
    <string name="daltonizer_mode_tritanomaly" msgid="481725854987912389">"Tritanomália (modrá-žltá)"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Nastavenia"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Zapnuté"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Vypnuté"</string>
    <string name="accessibility_feature_or_input_method_not_allowed" msgid="5950315477009501647">"Nie je povolené vašou organizáciou"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Ukážka"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Štandardné možnosti"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Jazyk"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Veľkosť textu"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Štýl titulkov"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Vlastné možnosti"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Farba pozadia"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Nepriehľadnosť pozadia"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Farba okna titulkov"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Nepriehľadnosť okna titulkov"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Farba textu"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Nepriehľadnosť textu"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Farba okraja"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Typ okraja"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Skupina písiem"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Titulky budú vyzerať takto."</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Predvolené"</string>
    <string name="color_title" msgid="4258931051732243983">"Farba"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"Predvolené"</string>
    <string name="color_none" msgid="3475640044925814795">"Žiadna"</string>
    <string name="color_white" msgid="8045195170201590239">"Biela"</string>
    <string name="color_gray" msgid="9192312087142726313">"Sivá"</string>
    <string name="color_black" msgid="7517353520909872561">"Čierna"</string>
    <string name="color_red" msgid="4949354900304125428">"Červená"</string>
    <string name="color_green" msgid="5537717328428845841">"Zelená"</string>
    <string name="color_blue" msgid="7731984529016953223">"Modrá"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Azúrová"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Žltá"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Purpurová"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Použiť službu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"Služba <xliff:g id="SERVICE">%1$s</xliff:g> vyžaduje nasledujúce funkcie:"</string>
    <string name="touch_filtered_warning" msgid="8644034725268915030">"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="3064686622453974606">"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="464101518421886337">"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="777577618063306751">"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="7882035264853248228">"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="1224075277603097951">"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="capability_title_receiveAccessibilityEvents" msgid="1869032063969970755">"Sledovať vaše akcie"</string>
    <string name="capability_desc_receiveAccessibilityEvents" msgid="2095111008854376237">"Dostávajte upozornenia aj pri interakcii s aplikáciami."</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Zastaviť službu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="2012273739481042318">"Ak sa dotknete klávesu OK, služba <xliff:g id="SERVICE">%1$s</xliff:g> sa zastaví."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Nie sú nainštalované žiadne služby"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"K dispozícii nie je žiadny popis."</string>
    <string name="settings_button" msgid="3006713718908152930">"Nastavenia"</string>
    <string name="print_settings" msgid="4742428530112487843">"Tlač"</string>
    <string name="print_settings_title" msgid="3685449667822217816">"Tlačové služby"</string>
    <string name="print_service_security_warning_title" msgid="2338435517408144841">"Použiť službu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="print_service_security_warning_summary" msgid="7567131958613064363">"Skôr ako sa váš dokument dostane do tlačiarne, môže prejsť jedným alebo viacerými servermi."</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Nie sú nainštalované žiadne služby"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Nenašli sa žiadne tlačiarne"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Nastavenia"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Pridať tlačiarne"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Zapnuté"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Vypnuté"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Pridať službu"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Pridať tlačiareň"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Hľadať"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Vyhľadávanie tlačiarní"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Služba bola vypnutá."</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Tlačové úlohy"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Tlačová úloha"</string>
    <string name="print_restart" msgid="8373999687329384202">"Spustiť znova"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Zrušiť"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Prebieha tlač úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Prebieha zrušenie úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Chyba tlačiarne – úloha <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Tlačiareň zablok. úlohu <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Vyhľadávacie pole je zobrazené"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Vyhľadávacie pole je skryté"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Batéria"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Čo využíva batériu"</string>
    <string name="power_usage_not_available" msgid="3214000535532434353">"Údaje o spotrebe nie sú k dispozícii."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"Zostáva <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do nabitia"</string>
    <string name="power_discharging_duration" msgid="1605929174734600590">"<xliff:g id="LEVEL">%1$s</xliff:g> – zostáva približne <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="power_charging" msgid="1779532561355864267">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATE">%2$s</xliff:g>"</string>
    <string name="power_charging_duration" msgid="2853265177761520490">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="TIME">%2$s</xliff:g> do úplného nabitia"</string>
    <string name="power_charging_duration_ac" msgid="3969186192576594254">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="TIME">%2$s</xliff:g> do úplného nabitia zo zásuvky"</string>
    <string name="power_charging_duration_usb" msgid="182405645340976546">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="TIME">%2$s</xliff:g> do úplného nabitia cez USB"</string>
    <string name="power_charging_duration_wireless" msgid="1829295708243159464">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="TIME">%2$s</xliff:g> do úplného nabitia bezdrôtovo"</string>
    <string name="power_usage_list_summary" msgid="2409288197839512482">"Využitie od posledného úplného dobitia"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Využitie batérie od odpojenia"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Využitie batérie od obnovenia"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> na batérii"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> od odpojenia"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Nabíjanie"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Obrazovka zapnutá"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS aktívne"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Prebudiť"</string>
    <string name="battery_stats_phone_signal_label" msgid="3537569115723850618">"Signál mobilnej siete"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Doba používania zariadenia"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Čas prevádzky siete Wi-Fi"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Čas prevádzky siete Wi-Fi"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Podrobnosti histórie"</string>
    <string name="details_title" msgid="3792801565213935385">"Podrobnosti používania"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Podrobnosti používania"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Upraviť spotrebu energie"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Zahrnuté balíčky"</string>
    <string name="power_screen" msgid="3023346080675904613">"Obrazovka"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Svetlo"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="6596471490976003056">"Telefón v pohotovostnom režime"</string>
    <string name="power_phone" msgid="5392641106474567277">"Hlasové hovory"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tablet je nečinný"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Telefón v stave nečinnosti"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Rôzne"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Nadsadená"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"Doba prevádzky procesora"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"CPU v popredí"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Zakázať režim spánku"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Pripojenie Wi-Fi aktívne"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tablet"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefón"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Odoslané pakety – mobilná sieť"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Prijaté pakety – mobilná sieť"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Jednotka GSM je aktívna"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Odoslané pakety – Wi‑Fi"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Prijaté pakety – Wi‑Fi"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Zvuk"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Video"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Doba zapnutia"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Doba bez signálu"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Celková kapacita batérie"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Vypočítaná spotreba energie"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Pozorovaná spotreba energie"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Vynútiť zastavenie"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Informácie o aplikácii"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Nastavenia aplikácie"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Nastavenia obrazovky"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Nastavenia Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Nastavenia Bluetooth"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Využitie batérie hlasovými hovormi"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Využitie batérie v stave nečinnosti tabletu"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Využitie batérie v stave nečinnosti"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Využitie batérie jednotkou GSM"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"V oblastiach bez pokrytia prepnite do režimu V lietadle"</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Batéria využívaná svetlom"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Využitie batérie obrazovkou a podsvietením"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Znížte jas obrazovky alebo interval vypnutia obrazovky"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Využitie batérie sieťou Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="3355461362094706957">"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="8069070756186680367">"Využitie batérie technológiou Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="1942935021750897422">"Keď technológiu Bluetooth nepoužívate, vypnite ju"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Skúste sa pripojiť k inému zariadeniu Bluetooth"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Využitie batérie aplikáciou"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Zastavte aplikáciu alebo ju odinštalujte"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Vyberte režim úspory batérie"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Táto aplikácia môže ponúkať nastavenia na zníženie používania batérie"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Využitie batérie používateľom"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Rôzna spotreba energie"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"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="5481865509489228603">"Nadsadená spotreba energie"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> od odpojenia"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Pri poslednom odpojení pre <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Využitie batérie celkom"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Obnoviť"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"OS Android"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Mediaserver"</string>
    <string name="battery_saver" msgid="1426682272004907982">"Šetrič batérie"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Zapnúť automaticky"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Nikdy"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="7536784431655058267">"%1$s batérie"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Štatistiky procesov"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Podrobné štatistiky spustených procesov"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Využitie pamäte"</string>
    <string name="process_stats_total_duration" msgid="2243876627952936205">"<xliff:g id="USEDRAM">%1$s</xliff:g> z <xliff:g id="TOTALRAM">%2$s</xliff:g> za <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"Pozadie"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"Popredie"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"V pamäti"</string>
    <string name="process_stats_memory_status" msgid="4251599550196193093">"Aktuálny stav pamäte zariadenia: <xliff:g id="MEMSTATE">%1$s</xliff:g>"</string>
    <string name="process_stats_os_label" msgid="4813434110442733392">"OS Android"</string>
    <string name="process_stats_os_native" msgid="5322428494231768472">"Natívne"</string>
    <string name="process_stats_os_kernel" msgid="1938523592369780924">"Jadro"</string>
    <string name="process_stats_os_zram" msgid="677138324651671575">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="6432533624875078233">"Vyrovnávacie pamäte"</string>
    <string name="process_stats_ram_use" msgid="976912589127397307">"Využitie RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="5398191511030462404">"Využitie RAM (pozadie)"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Spustené"</string>
    <string name="processes_subtitle" msgid="6827502409379462438">"Procesy"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Služby"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Trvanie"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Podrobnosti o pamäti"</string>
    <string name="mem_state_subtitle" msgid="2407238869781011933">"Stavy pamäte"</string>
    <string name="mem_use_subtitle" msgid="7319468770222422412">"Využitie pamäte"</string>
    <string name="mem_use_kernel_type" msgid="8698327165935012484">"Kernel"</string>
    <string name="mem_use_native_type" msgid="5976704902328347400">"Natívne"</string>
    <string name="mem_use_kernel_cache_type" msgid="6411475064463957513">"Vyrovnávacie pamäte jadra Kernel"</string>
    <string name="mem_use_zram_type" msgid="9087217476795358232">"ZRam swap"</string>
    <string name="mem_use_free_type" msgid="717708548454880840">"Voľné"</string>
    <string name="mem_use_total" msgid="6308786055749777934">"Celkové"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 hodiny"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 hodín"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 hodín"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 deň"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Zobraziť systém"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Použiť Uss (jedinečnú veľkosť súpravy)"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Typ štatistík"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"Pozadie"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"Popredie"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"V pamäti"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Hlasový vstup a výstup"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Nastavenia hlasového vstupu a výstupu"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Hlasové vyhľadávanie"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Klávesnica Android"</string>
    <string name="voice_category" msgid="1430370497125803904">"Reč"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Nastavenia hlasového vstupu"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Hlasový vstup"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Služby hlasového vstupu"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Režim úplných kľúčových slov a interakcií"</string>
    <string name="voice_recognizer_preference_summary" msgid="669880813593690527">"Režim jednoduchého prevodu reči na text"</string>
    <string name="voice_interaction_security_warning" msgid="6378608263983737325">"Táto služba hlasového vstupu za vás bude môcť neustále monitorovať hlas a ovládať aplikácie s povolenými hlasovými funkciami. Vychá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_settings" msgid="8186971894801348327">"Nastavenia prevodu textu na reč"</string>
    <string name="tts_settings_title" msgid="1237820681016639683">"Výstup prevodu textu na reč"</string>
    <string name="use_default_tts_settings_title" msgid="1577063839539732930">"Vždy používať moje nastavenia"</string>
    <string name="use_default_tts_settings_summary" msgid="5916421806783703823">"Predvolené nastavenia nižšie prepíšu nastavenia aplikácií"</string>
    <string name="tts_default_settings_section" msgid="5787915620218907443">"Predvolené nastavenia"</string>
    <string name="tts_default_synth_title" msgid="4755558388333117572">"Predvolený nástroj"</string>
    <string name="tts_default_synth_summary" msgid="7326298606388069173">"Nastavenie použitia nástroja na syntézu reči pri vyslovení textu"</string>
    <string name="tts_default_rate_title" msgid="6030550998379310088">"Rýchlosť reči"</string>
    <string name="tts_default_rate_summary" msgid="4061815292287182801">"Rýchlosť hovoreného textu"</string>
    <string name="tts_default_pitch_title" msgid="6135942113172488671">"Výška"</string>
    <string name="tts_default_pitch_summary" msgid="1328298665182885277">"Určuje zvuk hovoreného textu"</string>
    <string name="tts_default_lang_title" msgid="8018087612299820556">"Jazyk"</string>
    <string name="tts_lang_use_system" msgid="2679252467416513208">"Použiť jazyk systému"</string>
    <string name="tts_lang_not_selected" msgid="7395787019276734765">"Nebol vybratý jazyk"</string>
    <string name="tts_default_lang_summary" msgid="5219362163902707785">"Nastavenia jazyka hlasu pre hovorený text"</string>
    <string name="tts_play_example_title" msgid="7094780383253097230">"Vypočuť príklad"</string>
    <string name="tts_play_example_summary" msgid="8029071615047894486">"Prehrať krátku ukážku syntézy reči"</string>
    <string name="tts_install_data_title" msgid="4264378440508149986">"Nainštalovať hlasové údaje"</string>
    <string name="tts_install_data_summary" msgid="5742135732511822589">"Nainštalovať hlasové údaje potrebné na syntézu reči"</string>
    <string name="tts_data_installed_summary" msgid="9162111552859972809">"Hlas pre syntézu reči už je správne nainštalovaný."</string>
    <string name="tts_settings_changed_demo" msgid="4926518555912328645">"Nastavenia sa zmenili. Toto je príklad súčasného znenia."</string>
    <string name="tts_engine_error" msgid="3305141107104670703">"Vybratý nástroj nie je možné spustiť."</string>
    <string name="tts_engine_error_config" msgid="5820525416624637313">"Konfigurovať"</string>
    <string name="tts_engine_error_reselect" msgid="2415399149293842112">"Zvoliť iný nástroj"</string>
    <string name="tts_engine_security_warning" msgid="8786238102020223650">"Nástroj na syntézu reči môže zhromažďovať všetok hovorený text, vrátane osobných údajov, ako sú heslá alebo čísla kreditných kariet. Je založený na nástroji <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>. Chcete aktivovať nástroj na syntézu reči?"</string>
    <string name="tts_engine_network_required" msgid="1190837151485314743">"V prípade tohto jazyka je na prevod textu na rečový výstup potrebné pripojenie k sieti."</string>
    <string name="tts_default_sample_string" msgid="4040835213373086322">"Toto je príklad syntézy reči"</string>
    <string name="tts_status_title" msgid="7268566550242584413">"Stav predvoleného jazyka"</string>
    <string name="tts_status_ok" msgid="1309762510278029765">"Jazyk <xliff:g id="LOCALE">%1$s</xliff:g> je plne podporovaný"</string>
    <string name="tts_status_requires_network" msgid="6042500821503226892">"Jazyk <xliff:g id="LOCALE">%1$s</xliff:g> vyžaduje pripojenie k sieti"</string>
    <string name="tts_status_not_supported" msgid="4491154212762472495">"Jazyk <xliff:g id="LOCALE">%1$s</xliff:g> nie je podporovaný"</string>
    <string name="tts_status_checking" msgid="4983413982985913047">"Prebieha kontrola..."</string>
    <string name="tts_engines_section" msgid="7515470972378742429">"Moduly"</string>
    <string name="tts_engine_name_settings" msgid="4974538563074395920">"Nastavenia <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="tts_engine_name_is_enabled_summary" msgid="4909484006804022115">"Možnosť <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> je aktivovaná"</string>
    <string name="tts_engine_name_is_disabled_summary" msgid="7644198182255168200">"Nástroj <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> je zakázaný"</string>
    <string name="tts_engine_settings_section" msgid="2346105138448751893">"Nastavenia nástroja"</string>
    <string name="tts_engine_settings_title" msgid="3499112142425680334">"Nastavenia pre nástroj <xliff:g id="TTS_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="pico_languages_and_voices" msgid="4611320375917773238">"Jazyky a hlasy"</string>
    <string name="pico_installed" msgid="2452546687858267414">"Nainštalované"</string>
    <string name="pico_not_installed" msgid="6266845418419994311">"Nie je nainštalované"</string>
    <string name="pico_voice_summary_female" msgid="8047327176247727492">"Žena"</string>
    <string name="pico_voice_summary_male" msgid="8331266854058577610">"Muž"</string>
    <string name="tts_notif_engine_install_title" msgid="7000346872482649034">"Nainštal. nástroj syntézy reči"</string>
    <string name="tts_notif_engine_install_message" msgid="7250804349781973329">"Nástroj pred použ. povoľte."</string>
    <string name="tts_engine_settings_button" msgid="1030512042040722285">"Spustiť nastavenia nástroja"</string>
    <string name="tts_engine_preference_section_title" msgid="448294500990971413">"Preferovaný nástroj"</string>
    <string name="tts_general_section_title" msgid="4402572014604490502">"Všeobecné"</string>
    <string name="gadget_title" msgid="5519037532720577836">"Ovládanie napájania"</string>
    <string name="gadget_toggle_wifi" msgid="319262861956544493">"Prebieha aktualizácia nastavenia Wi-Fi"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Prebieha aktualizácia nastavenia Bluetooth"</string>
    <string name="gadget_state_template" msgid="5156935629902649932">"<xliff:g id="ID_1">%1$s</xliff:g> <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="gadget_state_on" msgid="6909119593004937688">"zapnuté"</string>
    <string name="gadget_state_off" msgid="5220212352953066317">"vypnuté"</string>
    <string name="gadget_state_turning_on" msgid="3395992057029439039">"zapínanie"</string>
    <string name="gadget_state_turning_off" msgid="2395546048102176157">"vypínanie"</string>
    <string name="gadget_wifi" msgid="4712584536500629417">"Wi-Fi"</string>
    <string name="gadget_bluetooth" msgid="8998572807378694410">"Bluetooth"</string>
    <string name="gadget_location" msgid="2974757497945178165">"Poloha"</string>
    <string name="gadget_sync" msgid="858895763714222152">"Synchronizácia"</string>
    <string name="gadget_brightness_template" msgid="930541920933123603">"Jas <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="gadget_brightness_state_auto" msgid="6667967252426515446">"automaticky"</string>
    <string name="gadget_brightness_state_full" msgid="6814570109772137631">"plné"</string>
    <string name="gadget_brightness_state_half" msgid="3696671957608774204">"polovičné"</string>
    <string name="gadget_brightness_state_off" msgid="946382262872753084">"vypnuté"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Úložisko poverení"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Inštalovať z úložiska"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Inštalácia z karty SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Inštalovať certifikáty z úložiska"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Inštalovať certifikáty z karty SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Vymazať poverenia"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Odstrániť všetky certifikáty"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Dôveryhodné poverenia"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Zobraziť dôveryhodné certifikáty CA"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Rozšírené"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Typ úložiska"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Hardvérové"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Iba softvérový"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Poverenia nie sú pre tohto používateľa k dispozícii"</string>
    <string name="credentials_install_gesture_explanation" msgid="7408921172253634829">"Inštaláciu poverení je potrebné potvrdiť nakreslením bezpečnostného vzoru."</string>
    <string name="credentials_unlock" msgid="385427939577366499"></string>
    <string name="credentials_unlock_hint" msgid="2301301378040499348">"Zadajte heslo pre úložisko poverení."</string>
    <string name="credentials_old_password" msgid="7553393815538684028">"Aktuálne heslo:"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Odstrániť všetok obsah?"</string>
    <string name="credentials_password_too_short" msgid="7502749986405522663">"Heslo musí mať aspoň 8 znakov."</string>
    <string name="credentials_wrong_password" msgid="2541932597104054807">"Nesprávne heslo."</string>
    <string name="credentials_reset_warning" msgid="5320653011511797600">"Nesprávne heslo. Do vymazania úložiska poverení vám zostáva jeden pokus."</string>
    <string name="credentials_reset_warning_plural" msgid="6514085665301095279">"Nesprávne heslo. Počet zostávajúcich pokusov do vymazania úložiska poverení: <xliff:g id="NUMBER">%1$d</xliff:g>."</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Úložisko poverení je vymazané"</string>
    <string name="credentials_not_erased" msgid="93461830775441220">"Úlož. poverení nemožno vymazať"</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Úložisko poverení je aktivované."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="6757119179588664966">"Pred použitím úložiska poverení musíte nastaviť kód PIN alebo heslo zámky obrazovky."</string>
    <string name="usage_access_title" msgid="332333405495457839">"Aplik. s príst. k používaniu"</string>
    <string name="allow_usage_access_title" msgid="2134237975190472249">"Povoliť prístup?"</string>
    <string name="allow_usage_access_message" msgid="2295847177051307496">"Ak jej povolíte prístup, táto aplikácia uvidí informácie o ostatných aplikáciách na zariadení, napríklad ako často ich používate."</string>
    <string name="emergency_tone_title" msgid="1055954530111587114">"Tiesňové vyzváňanie"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Nastaviť správanie pri tiesňovom volaní"</string>
    <string name="privacy_settings" msgid="5446972770562918934">"Zálohovanie a obnova"</string>
    <string name="privacy_settings_title" msgid="4856282165773594890">"Zálohovanie a obnova"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Zálohovať a obnoviť"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Osobné údaje"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Zálohovať moje údaje"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Zálohovať údaje aplikácií, heslá sietí Wi-Fi a ďalšie nastavenia na serveroch Google"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Účet zálohy"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Momentálne nie sú záložné údaje ukladané do žiadneho účtu"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Zahrnúť dáta aplikácií"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Automatické obnovenie"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Pri preinštalovaní aplikácie obnoviť zálohované údaje a nastavenia"</string>
    <string name="backup_inactive_title" msgid="5355557151569037197">"Služba zálohovania nie je aktívna."</string>
    <string name="backup_inactive_summary" msgid="7630412094703573180">"Túto možnosť nastavujú pravidlá pre zariadenie."</string>
    <string name="local_backup_password_title" msgid="3860471654439418822">"Heslo záloh v počítači"</string>
    <string name="local_backup_password_summary_none" msgid="393503434408227110">"Úplné zálohy na počítači nie sú momentálne chránené"</string>
    <string name="local_backup_password_summary_change" msgid="2731163425081172638">"Dotykom zmeníte alebo odstránite heslo pre úplné zálohy do počítača"</string>
    <string name="local_backup_password_toast_success" msgid="582016086228434290">"Nové záložné heslo je nastavené"</string>
    <string name="local_backup_password_toast_confirmation_mismatch" msgid="3495167398824569524">"Nové heslo a potvrdenie sa nezhodujú"</string>
    <string name="local_backup_password_toast_validation_failure" msgid="5646377234895626531">"Nastavenie záložného hesla zlyhalo"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Chcete zastaviť zálohovanie hesiel sietí Wi-Fi, záložiek, ďalších nastavení a údajov aplikácií a vymazať všetky kópie na serveroch Google?"</string>
    <string name="device_admin_settings_title" msgid="1335557832906433309">"Nastavenia správy zariadení"</string>
    <string name="active_device_admin_msg" msgid="6930903262612422111">"Správca zariadení"</string>
    <string name="remove_device_admin" msgid="3596845261596451437">"Deaktivovať"</string>
    <string name="select_device_admin_msg" msgid="2645509057946368094">"Správcovia zariadenia"</string>
    <string name="no_device_admins" msgid="702695100241728775">"Nie je k dispozícii žiadny správca nastavení"</string>
    <string name="managed_profile_device_admin_info" msgid="5048846624960067582">"Ak chcete zakázať aplikácii <xliff:g id="APP_NAME">%1$s</xliff:g> prístup k vášmu pracovnému profilu, odstráňte profil v časti Nastavenia &gt; Účty"</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Osobné"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Práca"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Nie sú k dispozícii žiadne agenty dôvery"</string>
    <string name="add_device_admin_msg" msgid="6246742476064507965">"Aktivovať správcu zariadenia?"</string>
    <string name="add_device_admin" msgid="7133327675884827091">"Aktivovať"</string>
    <string name="device_admin_add_title" msgid="7705551449705676363">"Správca zariadení"</string>
    <string name="device_admin_warning" msgid="2026747446313628233">"Aktiváciou tohto správcu 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_status" msgid="4252975713178851910">"Správca je aktívny 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="6249331160676175009">"Aktivovať aplikáciu Správca profilu?"</string>
    <string name="adding_profile_owner_warning" msgid="6469780138110334180">"Ak budete pokračovať, váš používateľ bude spravovaný správcom, ktorý bude môcť okrem osobných údajov ukladať aj priradené ú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="untitled_apn" msgid="1230060359198685513">"Bez názvu"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Všeobecné"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Denník upozornení"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Tón zvonenia a vibrovanie"</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"Systém"</string>
    <string name="wifi_setup_title" msgid="2970260757780025029">"Nastavenie Wi-Fi"</string>
    <string name="wifi_setup_title_editing_network" msgid="6020614644556717979">"Pripojenie k sieti Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_connecting_network" msgid="5572226790101017822">"Prebieha pripájanie k sieti Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>..."</string>
    <string name="wifi_setup_title_connected_network" msgid="1608788657122010919">"Pripojené k sieti Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Pridanie siete"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Nepripojené"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Pridať sieť"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Obnoviť zoznam"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Preskočiť"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"Ďalej"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Späť"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Podrobnosti siete"</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Pripojiť"</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Odstrániť"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Uložiť"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Zrušiť"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Vyhľadávanie sietí..."</string>
    <string name="wifi_setup_status_select_network" msgid="7519563569903137003">"Dotykom na sieť sa k nej pripojíte"</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Pripojiť k existujúcej sieti"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Pripojenie k nezabezpečenej sieti"</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Zadajte konfiguráciu siete"</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Pripojiť k novej sieti"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Pripája sa..."</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Prejsť na ďalší krok"</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="5335338851032315905">"Protokol EAP nie je podporovaný."</string>
    <string name="wifi_setup_eap_not_supported" msgid="1955087534276570962">"Počas inštalácie nie je možné konfigurovať pripojenie k sieti Wi-Fi cez protokol EAP. Po inštalácii to môžete vykonať v sekcii Nastavenia &gt; Bezdrôtové pripojenie a siete."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"Pripájanie môže trvať niekoľko minút..."</string>
    <string name="wifi_setup_description_connected" msgid="736032046548460779">"Ak chcete pokračovať v nastavovaní, dotknite sa možnosti "<b>"Ďalej"</b>".\n\nAk sa chcete pripojiť k inej sieti Wi-Fi, dotknite sa možnosti "<b>"Späť"</b>"."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Synchronizácia je povolená"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Synchronizácia bola zakázaná"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Prebieha synchronizácia"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Chyba synchronizácie"</string>
    <string name="sync_failed" msgid="1696499856374109647">"Synchronizácia zlyhala"</string>
    <string name="sync_active" msgid="8476943765960863040">"Synchronizácia je aktívna"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Synchronizácia"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Vyskytli sa problémy so synchronizáciou. Služba bude čoskoro obnovená."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Pridať účet"</string>
    <string name="managed_profile_not_available_label" msgid="3489771164851107822">"Pracovný profil zatiaľ nie je k dispozícii"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Odstrániť pracovný profil"</string>
    <string name="background_data" msgid="5779592891375473817">"Údaje na pozadí"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Aplikácie môžu kedykoľvek synchronizovať, odosielať a prijímať údaje"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Zakázať údaje na pozadí?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Zakázanie údajov na pozadí šetrí batériu a znižuje objem použitých údajov. Niektoré aplikácie môžu používať dátové pripojenie na pozadí aj napriek tomuto nastaveniu."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Automatická synch. údajov aplikácií"</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Synchronizácia je ZAPNUTÁ"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Synchronizácia je VYPNUTÁ"</string>
    <string name="sync_error" msgid="5060969083117872149">"Chyba synchronizácie"</string>
    <string name="last_synced" msgid="4242919465367022234">"Posledná synchronizácia: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Prebieha synchronizácia..."</string>
    <string name="settings_backup" msgid="2274732978260797031">"Zálohovať nastavenia"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Zálohovať moje nastavenia"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Synchronizovať"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Zrušiť synchronizáciu"</string>
    <string name="sync_one_time_sync" msgid="6766593624598183090">"Dotykom vykonáte synchronizáciu<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Kalendár"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Kontakty"</string>
    <string name="sync_plug" msgid="3905078969081888738"><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="6205903695598000286">"Nastavenia synchronizácie aplikácie"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Údaje a synchronizácia"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Zmeniť heslo"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Nastavenia účtu"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Odstrániť účet"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Pridanie účtu"</string>
    <string name="finish_button_label" msgid="481587707657751116">"Dokončiť"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Odstrániť účet?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Odstránením tohto účtu budú z tabletu odstránené aj všetky správy, kontakty a ďalšie údaje!"</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Odstránením tohto účtu budú z telefónu odstránené aj všetky správy, kontakty a ďalšie údaje."</string>
    <string name="remove_account_failed" msgid="4010643669489606536">"Správca túto zmenu zakázal"</string>
    <string name="provider_label" msgid="7724593781904508866">"Zobraziť odbery"</string>
    <!-- no translation found for sync_item_title (4782834606909853006) -->
    <skip />
    <string name="cant_sync_dialog_title" msgid="8923508322291625282">"Nie je možné ručne synchronizovať"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Synchronizácia tejto položky je momentálne zakázaná. Ak chcete toto nastavenie zmeniť, dočasne zapnite prenos údajov na pozadí a automatickú synchronizáciu."</string>
    <string name="wimax_settings" msgid="2655139497028469039">"4G"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"Adresa 4G MAC"</string>
    <string name="enter_password" msgid="8035706727471334122">"Ak chcete spustiť Android, zadajte heslo."</string>
    <string name="enter_pin" msgid="5305333588093263790">"Ak chcete spustiť Android, zadajte číslo PIN."</string>
    <string name="enter_pattern" msgid="4187435713036808566">"Ak chcete spustiť Android, nakreslite vzor."</string>
    <string name="cryptkeeper_wrong_pattern" msgid="8423835922362956999">"Nesprávny vzor"</string>
    <string name="cryptkeeper_wrong_password" msgid="5200857195368904047">"Nesprávne heslo"</string>
    <string name="cryptkeeper_wrong_pin" msgid="755720788765259382">"Nesprávny kód PIN"</string>
    <string name="checking_decryption" msgid="8287458611802609493">"Kontroluje sa…"</string>
    <string name="starting_android" msgid="8581493237458496835">"Spúšta sa Android"</string>
    <string name="delete" msgid="4219243412325163003">"Odstrániť"</string>
    <string name="misc_files" msgid="6720680815969643497">"Rôzne súbory"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"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="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> z <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Vybrať všetko"</string>
    <string name="hdcp_checking_title" msgid="8605478913544273282">"Kontrola HDCP"</string>
    <string name="hdcp_checking_dialog_title" msgid="5141305530923283">"Nastaviť spôsob kontroly HDCP"</string>
    <string name="debug_debugging_category" msgid="6781250159513471316">"Ladenie"</string>
    <string name="debug_app" msgid="8349591734751384446">"Vybrať aplikáciu na ladenie"</string>
    <string name="debug_app_not_set" msgid="718752499586403499">"Nie je nastavená žiadna aplikácia na ladenie"</string>
    <string name="debug_app_set" msgid="2063077997870280017">"Aplikácia na ladenie: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="select_application" msgid="5156029161289091703">"Výber aplikácie"</string>
    <string name="no_application" msgid="2813387563129153880">"Nič"</string>
    <string name="wait_for_debugger" msgid="1202370874528893091">"Čakať na ladiaci nástroj"</string>
    <string name="wait_for_debugger_summary" msgid="1766918303462746804">"Aplikácia čaká na pripojenie ladiaceho nástroja"</string>
    <string name="debug_input_category" msgid="1811069939601180246">"Vstup"</string>
    <string name="debug_drawing_category" msgid="6755716469267367852">"Nákres"</string>
    <string name="debug_hw_drawing_category" msgid="6220174216912308658">"Hardvérom zrýchlené vykresľovanie"</string>
    <string name="media_category" msgid="4388305075496848353">"Médiá"</string>
    <string name="debug_monitoring_category" msgid="7640508148375798343">"Monitorovanie"</string>
    <string name="strict_mode" msgid="1938795874357830695">"Prísny režim bol povolený"</string>
    <string name="strict_mode_summary" msgid="142834318897332338">"Blikať pri dlhých operáciách hlavného vlákna"</string>
    <string name="pointer_location" msgid="6084434787496938001">"Umiestnenie ukazovateľa"</string>
    <string name="pointer_location_summary" msgid="840819275172753713">"Zobraziť prekryvnú vrstvu s aktuálnymi údajmi o dotykoch"</string>
    <string name="show_touches" msgid="1356420386500834339">"Zobrazovať dotyky"</string>
    <string name="show_touches_summary" msgid="6684407913145150041">"Vizuálne znázorňovať dotyky"</string>
    <string name="show_screen_updates" msgid="5470814345876056420">"Zobraziť obnovenia obsahu"</string>
    <string name="show_screen_updates_summary" msgid="2569622766672785529">"Rozblikať obsah okna pri aktualizácii"</string>
    <string name="show_hw_screen_updates" msgid="5036904558145941590">"Zobraziť obnovenia s GPU"</string>
    <string name="show_hw_screen_updates_summary" msgid="1115593565980196197">"Rozblikať zobrazenia v oknách vykresľované GPU"</string>
    <string name="show_hw_layers_updates" msgid="5645728765605699821">"Zobr. aktual. HW vrstiev"</string>
    <string name="show_hw_layers_updates_summary" msgid="5296917233236661465">"Rozblikať zelene hardvérové vrstvy pri obnovení"</string>
    <string name="debug_hw_overdraw" msgid="2968692419951565417">"Ladenie prekresľovania GPU"</string>
    <string name="disable_overlays" msgid="2074488440505934665">"Zakázať hardvérové prekrytia"</string>
    <string name="disable_overlays_summary" msgid="3578941133710758592">"Vždy používať GPU na skladanie obrazovky"</string>
    <string name="simulate_color_space" msgid="6745847141353345872">"Simulácia far. priestoru"</string>
    <string name="enable_opengl_traces_title" msgid="6790444011053219871">"Trasovanie OpenGL"</string>
    <string name="use_awesomeplayer" msgid="1583337008516364226">"Použiť AwesomePlayer (zastarané)"</string>
    <string name="use_awesomeplayer_summary" msgid="6757734070733387140">"Použiť na prehrávanie médií AwesomePlayer (nie NuPlayer)"</string>
    <string name="usb_audio_disable_routing" msgid="8114498436003102671">"Vyp. smer. zvuku do USB"</string>
    <string name="usb_audio_disable_routing_summary" msgid="980282760277312264">"Vyp. aut. smer. zvuku do zvukových periférií USB"</string>
    <string name="debug_layout" msgid="5981361776594526155">"Zobraziť ohraničenia"</string>
    <string name="debug_layout_summary" msgid="2001775315258637682">"Zobraziť v klipe ohraničenie, okraje a pod."</string>
    <string name="force_rtl_layout_all_locales" msgid="2259906643093138978">"Rozloženia sprava doľava"</string>
    <string name="force_rtl_layout_all_locales_summary" msgid="9192797796616132534">"Vynútiť pre všetky jazyky rozloženie obrazovky sprava doľava"</string>
    <string name="show_cpu_usage" msgid="2389212910758076024">"Zobraziť využitie CPU"</string>
    <string name="show_cpu_usage_summary" msgid="2113341923988958266">"Prekryvná vrstva s aktuálnym využitím procesora"</string>
    <string name="force_hw_ui" msgid="6426383462520888732">"Vykresľovat pomocou GPU"</string>
    <string name="force_hw_ui_summary" msgid="5535991166074861515">"Používať GPU na dvojrozmerné vykresľovanie"</string>
    <string name="force_msaa" msgid="7920323238677284387">"Vynútiť 4x MSAA"</string>
    <string name="force_msaa_summary" msgid="9123553203895817537">"Povoliť 4x MSAA v aplikáciách OpenGL ES 2.0"</string>
    <string name="show_non_rect_clip" msgid="505954950474595172">"Ladenie operácií neobdĺžnikových klipov"</string>
    <string name="track_frame_time" msgid="6146354853663863443">"Profil vykresľovania GPU"</string>
    <string name="window_animation_scale_title" msgid="6162587588166114700">"Mierka animácie okna"</string>
    <string name="transition_animation_scale_title" msgid="387527540523595875">"Mierka animácie premeny"</string>
    <string name="animator_duration_scale_title" msgid="3406722410819934083">"Mierka dĺžky animácie"</string>
    <string name="overlay_display_devices_title" msgid="5364176287998398539">"Simulovať sekundárne displeje"</string>
    <string name="enable_multi_window" msgid="1091779249819137016">"Režim viacerých okien"</string>
    <string name="enable_multi_window_summary" msgid="5837641304114783514">"Viacero súčasných aktivít na obrazovke"</string>
    <string name="confirm_enable_multi_window_title" msgid="950964546995895971">"Chcete povoliť režim viacerých okien?"</string>
    <string name="confirm_enable_multi_window_text" msgid="565834092374755117">"UPOZORNENIE: Ide o vysoko experimentálnu funkciu umožňujú vykonávať na obrazovke súčasne viacero aktivít prostredníctvom používateľského rozhrania Nedávne aplikácie. Niektoré aplikácie môžu pri použití tejto funkcie zlyhať alebo nemusia fungovať správne."</string>
    <string name="debug_applications_category" msgid="4206913653849771549">"Aplikácie"</string>
    <string name="immediately_destroy_activities" msgid="8366775083630234121">"Neuchovávať aktivity"</string>
    <string name="immediately_destroy_activities_summary" msgid="3592221124808773368">"Zničiť každú aktivitu, hneď ako ju používateľ ukončí"</string>
    <string name="app_process_limit_title" msgid="4280600650253107163">"Limit procesov na pozadí"</string>
    <string name="show_all_anrs" msgid="28462979638729082">"Zobrazovať všetky ANR"</string>
    <string name="show_all_anrs_summary" msgid="641908614413544127">"Zobrazovať dialóg „Aplikácia neodpovedá“ aj pre aplikácie na pozadí"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Využitie dát"</string>
    <string name="data_usage_app_summary_title" msgid="4147258989837459172">"Využitie dát aplikáciou"</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"Účtovanie dát operátora sa môže pre vaše zariadenie líšiť."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Využitie aplikácií"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"INFORMÁCIE O APLIKÁCII"</string>
    <string name="data_usage_cellular_data" msgid="4859424346276043677">"Mobilné dáta"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Nastavenie dátového limitu"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Cyklus počítania dát"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Využitie aplikácií"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Dátový roaming"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Obmedzenie dátových prenosov na pozadí"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Povoliť údaje na pozadí"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Samostatné použitie 4G"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Zobraziť využitie Wi-Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Skryť využitie siete Wi‑Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Zobraziť využitie siete Ethernet"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Skryť využitie Ethernetu"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Obmedzenia siete"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Automatická synchronizácia údajov"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"SIM karty"</string>
    <string name="data_usage_menu_cellular_networks" msgid="5243515735055652279">"Mobilné siete"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Autom. synchronizácia údajov"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Autom. synchr. osobných údajov"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Autom. synchr. pracov. údajov"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Zmeniť cyklus..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Deň v mesiaci, kedy sa má obnoviť počítanie dátových prenosov:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"V tomto období nevyužili dáta žiadne aplikácie."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"V popredí"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Pozadie"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"obmedzené"</string>
    <string name="data_usage_disable_mobile" msgid="2613595056882494652">"Vypnúť mobilné dáta?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="3934211003105066167">"Nastaviť limit mobilných dát"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Nastaviť dátový limit siete 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Nastaviť dát. limit sietí 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Nastaviť dát. limit Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="2084466270343460491">"Mob. sieť"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="7219011330831181312">"Mob. sieť"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Žiadne"</string>
    <string name="data_usage_enable_mobile" msgid="5900650720568852325">"Mobilné dáta"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"Dátové prenosy 2G a 3G"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"Dátové prenosy 4G"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Popredie:"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"Pozadie:"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Nastavenia aplikácie"</string>
    <string name="data_usage_app_restrict_background" msgid="7510046552380574925">"Obmedziť dáta aplikácií na pozadí"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="3720075732277934106">"Zakázať dáta na pozadí v mobilných sieťach."</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="1446565717342917727">"Ak chcete obmedz. dáta na poz. pre túto apl., zadajte limit mobil. dát."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Obmedziť údaje na pozadí?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5871168521456832764">"Ak budú dostupné iba mobilné siete, môže táto funkcia spôsobiť, že aplikácie, ktoré vyžadujú dáta na pozadí, nebudú fungovať.\n\nVhodnejšie spôsoby ovládania využitia dát nájdete v nastaveniach aplikácie."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="4674085030810350875">"Dáta na pozadí je možné obmedziť iba v prípade, že zadáte limit využitia mobilných dát."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Zapnúť automat. synchr. údajov?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"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="8651376294887142858">"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="9013139130490125793">"Vypnúť automat. synchr. údajov?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4744145757533455623">"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="1373797281540188533">"Dátum obnovenia cyklu sledovania prenesených dát"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Dátum v každom mesiaci:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Nastaviť"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Nastaviť upozornenie o využívaní údajov"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Nastaviť limit využívania údajov"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Nastavuje sa obmedzenie dátových prenosov"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="5788774061143636263">"Keď tablet dosiahne stanovený limit, dátové pripojenie k mobilnej sieti bude vypnuté.\n\nPretože sa prenesené dáta merajú pomocou tabletu a operátor ich môže účtovať odlišne, je vhodné nastaviť nízky limit."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3511301596446820549">"Keď telefón dosiahne stanovený limit, dátové pripojenie k mobilnej sieti bude vypnuté.\n\nPretože sa prenesené dáta merajú pomocou telefónu a operátor ich môže účtovať odlišne, je vhodné nastaviť nízky limit."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Obmedziť údaje na pozadí?"</string>
    <string name="data_usage_restrict_background" msgid="8210134218644196511">"Ak obmedzíte využitie mobilných dát 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="3262993384666280985">"Ak obmedzíte využitie mobilných dát na pozadí, niektoré aplikácie a služby nebudú fungovať, dokým sa nepripojíte k sieti Wi-Fi.\n\nToto nastavenie ovplyvní používateľov tohto tabletu."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="4352615206362479722">"Ak obmedzíte využitie mobilných dát na pozadí, niektoré aplikácie a služby nebudú fungovať, dokým sa nepripojíte k sieti Wi-Fi.\n\nToto nastavenie ovplyvní používateľov tohto telefónu."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"upozornenie"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039"><font size="12">"limit:"</font>\n<font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Odstránené aplikácie"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Odstránené aplikácie a používatelia"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"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="4091294280619255237">"<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="5961720793603268572">"<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="1625833170144610767">"<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="7383175371006596441">"Obmedzenia siete"</string>
    <string name="data_usage_metered_body" msgid="3262343834446126044">"Keď sú údaje na pozadí obmedzené, siete s meraným objemom údajov sa považujú za rovnaké ako mobilné siete. V prípade veľkých sťahovaných súborov vás môžu aplikácie upozorniť na tieto siete ešte pred ich použitím."</string>
    <string name="data_usage_metered_mobile" msgid="2326986339431119372">"Mobilné siete"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"Siete Wi‑Fi s meranými údajmi"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Zapnite rozhranie Wi-Fi a vyberte siete s meraným objemom údajov"</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Účtovanie dát operátora sa môže v prípade vášho zariadenia líšiť."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Tiesňové volanie"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Späť na hovor"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Názov"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Typ"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Adresa servera"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"Šifrovanie protokolu PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"Tajný kľúč L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"Identifikátor protokolu IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Predzdieľaný kľúč protokolu IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"Používateľský certifikát protokolu IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"Certifikát CA protokolu IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Certifikát servera IPSec"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Zobraziť rozšírené možnosti"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Vyhľadávacie domény DNS"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"Servery DNS (napr. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Presmerovávacie trasy (napr. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Používateľské meno"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Heslo"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Uložiť informácie o účte"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(nepoužité)"</string>
    <string name="vpn_no_ca_cert" msgid="2095005387500126113">"(neoverovať server)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(prijatý zo servera)"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Zrušiť"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Uložiť"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Pripojiť"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Upraviť profil siete VPN"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Pripojiť k profilu <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Pridať profil siete VPN"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Upraviť profil"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Odstrániť profil"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Vždy zapnutá sieť VPN"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Vyberte profil siete VPN, ku ktorej chcete mať vždy pripojenie. Prenos údajov bude povolený len pri pripojení k tejto sieti VPN."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Žiadna"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Vždy zapnutá sieť VPN vyžaduje adresu IP pre server aj DNS."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Nie je k dispozícii žiadne sieťové pripojenie. Skúste to znova neskôr."</string>
    <string name="vpn_missing_cert" msgid="7972907102570411501">"Chýba certifikát. Upravte profil."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Systém"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Používateľ"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Zakázať"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Povoliť"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Odstrániť"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Povoliť systémový certifikát CA?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Zakázať systémový certifikát CA?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Natrvalo odstrániť používateľský certifikát CA?"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Kontrola pravopisu"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Tu zadajte aktuálne heslo pre úplné zálohy"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Tu zadajte nové heslo pre úplné zálohy"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Tu zadajte znova nové heslo pre úplné zálohy"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Nastaviť heslo pre zálohy"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Zrušiť"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Ďalšie aktualizácie systému"</string>
    <string name="selinux_status_disabled" msgid="924551035552323327">"Zakázané"</string>
    <string name="selinux_status_permissive" msgid="6004965534713398778">"Mierne"</string>
    <string name="selinux_status_enforcing" msgid="2252703756208463329">"Prísne"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Sieť môže byť monitorovaná"</string>
    <string name="done_button" msgid="1991471253042622230">"Hotovo"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="5339377665264149395">"Monitorovanie siete"</string>
    <string name="ssl_ca_cert_info_message" msgid="4583879256548819713">"Toto zariadenie je spravované nasledujúcou doménou:\n<xliff:g id="MANAGING_DOMAIN">%s</xliff:g>\n\nSprávca môže monitorovať vašu aktivitu v sieti vrátane e-mailov, aplikácií a zabezpečených webov.\n\nAk chcete získať viac informácií, kontaktujte svojho správcu."</string>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"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>
    <string name="ssl_ca_cert_settings_button" msgid="8760495070836213605">"Skontrolovať dôveryhodné poverenia"</string>
    <string name="user_settings_title" msgid="6151874007858148344">"Používatelia"</string>
    <string name="user_list_title" msgid="7937158411137563543">"Používatelia a profily"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Pridať používateľa alebo profil"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Pridať používateľa"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Obmedzený profil"</string>
    <string name="user_need_lock_message" msgid="2596365678651842785">"Pred vytvorením obmedzeného profilu je nutné najprv nastaviť zámku obrazovky na ochranu aplikácií a osobných údajov."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Nastaviť uzamknutie"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Nenastavené"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Nie je nastavený – obmedzený profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="1659125858619760573">"Pracovný profil (nie je nastavený)"</string>
    <string name="user_owner" msgid="3879126011135546571">"Vlastník"</string>
    <string name="user_you" msgid="1639158809315025986">"Vy (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Prezývka"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Pridať"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Používatelia majú svoje vlastné aplikácie a obsah"</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Môžete obmedziť prístup k aplikáciám a obsahu z vášho účtu"</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Používateľ"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Obmedzený profil"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"Pridať nového používateľa?"</string>
    <string name="user_add_user_message_long" msgid="718192651887726259">"Vytvorením ďalších používateľov môžete toto zariadenie zdieľať s inými ľuďmi. Každý používateľ má svoje prostredie, ktoré si môže prispôsobiť vlastnými aplikáciami, tapetou atď. Používatelia tiež môžu upraviť nastavenia zariadenia (napr. Wi-Fi), ktoré ovplyvnia všetkých ostatných používateľov.\n\nKeď pridáte nového používateľa, musí si nastaviť vlastný priestor.\n\nAkýkoľvek používateľ môže aktualizovať aplikácie všetkých ostatných používateľov."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Keď pridáte nového používateľa, musí si nastaviť vlastný priestor.\n\nAkýkoľvek používateľ môže aktualizovať aplikácie všetkých ostatných používateľov."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Chcete teraz nastaviť používateľa?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"Uistite sa, že je daná osoba k dispozícii a môže si na zariadení nastaviť svoj priestor."</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Nastaviť profil?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Nastaviť teraz"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Teraz nie"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="8440449301994432789">"Používateľov môže spravovať iba vlastník tabletu."</string>
    <string name="user_cannot_manage_message" product="default" msgid="1133251987818014757">"Používateľov môže spravovať iba vlastník telefónu."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Profily s obmedzeniami nemôžu pridávať účty"</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Odstrániť <xliff:g id="USER_NAME">%1$s</xliff:g> zo zariadenia"</string>
    <string name="user_add_on_lockscreen_menu" msgid="3025132738715222247">"Pridávať použív. pri uzamknutí"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Nový používateľ"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Nový profil"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Chcete odstrániť svoj profil?"</string>
    <string name="user_confirm_remove_title" msgid="1163721647646152032">"Odstrániť používateľa?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Odstrániť tento profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"Odstrániť pracovný profil?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="8167855311779740207">"Prídete o miesto v pamäti a údaje v tomto tablete. Táto akcia sa nedá vrátiť späť."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="5391888073786090274">"Prídete o miesto v pamäti a údaje v tomto telefóne. Táto akcia sa nedá vrátiť späť."</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"Odstránia sa všetky aplikácie a údaje."</string>
    <string name="work_profile_confirm_remove_message" msgid="7593793549364168783">"Všetky aplikácie a údaje v tomto profile budú odstránené."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"Odstránia sa všetky aplikácie a údaje."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Pridáv. nového používateľa..."</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Odstrániť používateľa"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Odstrániť"</string>
    <string name="user_guest" msgid="8475274842845401871">"Hosť"</string>
    <string name="user_exit_guest_title" msgid="5613997155527410675">"Odstrániť hosťa"</string>
    <string name="user_exit_guest_confirm_title" msgid="3405527634738147409">"Odstrániť hosťa?"</string>
    <string name="user_exit_guest_confirm_message" msgid="2194459201944413257">"Všetky aplikácie a údaje v tejto relácii budú odstránené."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Odstrániť"</string>
    <string name="user_enable_calling" msgid="5128605672081602348">"Zapnúť telefonické hovory"</string>
    <string name="user_enable_calling_sms" msgid="9172507088023097063">"Zapnúť telefonické hovory a správy SMS"</string>
    <string name="user_remove_user" msgid="6490483480937295389">"Odstrániť používateľa"</string>
    <string name="user_enable_calling_confirm_title" msgid="4315789475268695378">"Zapnúť telefonické hovory?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"S týmto používateľom sa bude zdieľať história hovorov."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="7243308401401932681">"Zapnúť telefonické hovory a správy SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="4025082715546544967">"S týmto používateľom sa bude zdieľať história hovorov a správ SMS."</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Povoliť aplikácie a obsah"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Aplikácie s obmedzením"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Rozbaliť nastavenia aplikácie"</string>
    <string name="home_app_uninstall_button" msgid="6808453012607962899">"Odinštalovať túto aplikáciu"</string>
    <string name="only_one_home_message" msgid="3538846733750242759">"Nastavenia domovskej stránky zostanú skryté do nainštalovania ďalšej aplikácie pre domovskú stránku."</string>
    <string name="global_change_warning" product="tablet" msgid="8045013389464294039">"Toto nastavenie ovplyvní všetkých používateľov tohto tabletu."</string>
    <string name="global_change_warning" product="default" msgid="2461264421590324675">"Toto nastavenie ovplyvní všetkých používateľov tohto telefónu."</string>
    <string name="global_locale_change_title" msgid="5956281361384221451">"Zmeniť jazyk"</string>
    <string name="global_font_change_title" msgid="1887126466191012035">"Zmeniť veľkosť písma"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Platby mobilom"</string>
    <string name="google_wallet" msgid="9122936252378589227">"Peňaženka Google"</string>
    <string name="nfc_payment_no_apps" msgid="2481080809791416010">"Plaťte jedným dotykom"</string>
    <string name="nfc_payment_favor_foreground" msgid="8881893980929835838">"Uprednostniť aplikácie v popredí"</string>
    <string name="nfc_payment_learn_more" msgid="5583407773744324447">"Viac informácií"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Viac..."</string>
    <string name="nfc_payment_menu_item_add_service" msgid="2885947408068969081">"Vyhľadať aplikácie"</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Nastaviť ako predvoľbu?"</string>
    <string name="nfc_payment_set_default" msgid="8961120988148253016">"Chcete pri platbách mobilom vždy používať aplikáciu <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="3803693771001226795">"Chcete pri platbách mobilom namiesto aplikácie <xliff:g id="APP_1">%2$s</xliff:g> vždy používať aplikáciu <xliff:g id="APP_0">%1$s</xliff:g>?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Obmedzenia"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Odstrániť obmedzenia"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Zmeniť kód PIN"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Zobraziť upozornenia"</string>
    <string name="help_label" msgid="6886837949306318591">"Pomocník a spät. väzba"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Účet pre obsah"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID fotografie"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Extrémne hrozby"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Prijímať upozornenia na extrémne ohrozenie života a majetku"</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Závažné hrozby"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Prijímať upozornenia na závažné ohrozenie života a majetku"</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"Upozornenia AMBER"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Prijímať bulletiny o únosoch detí"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Opakovať"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Povoliť nástroj Správca hovorov"</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Povoliť tejto službe spravovať spôsob uskutočňovania hovorov."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Správca hovorov"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2451014351355183338">"Núdzové vysielania"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Sieťoví operátori"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Názvy prístupových bodov"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="5808043757309522392">"Zlepšený režim 4G LTE"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1376589643017218924">"Zlepšiť hovory a správy pomocou dátového pripojenia LTE (odporúčané)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Preferovaný typ siete"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (odporúčané)"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"Pracovná SIM karta"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Prístup k aplikáciám a obsahu"</string>
    <string name="user_rename" msgid="8523499513614655279">"PREMENOVAŤ"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Nastaviť obmedzenia aplikácií"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Riadi: <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Táto aplikácia má prístup k vašim účtom"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="6968697624437267294">"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="8889556384136994814">"Siete Wi-Fi a mobilné siete"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Povoliť úpravu nastavení sietí Wi-Fi a mobilných sietí"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Povoliť úpravy párovania a nastavení rozhrania Bluetooth"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Povoliť výmenu dát, keď sa toto zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> dotkne iného zariadenia s funkciou NFC"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Povoliť výmenu údajov, ak sa tablet dotýka iného zariadenia"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Povoliť výmenu údajov, ak sa telefón dotýka iného zariadenia"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Poloha"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Povoliť aplikáciám používať informácie o polohe"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Späť"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Ďalej"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Dokončiť"</string>
    <string name="user_image_take_photo" msgid="1280274310152803669">"Odfotiť"</string>
    <string name="user_image_choose_photo" msgid="7940990613897477057">"Vybrať fotku z Galérie"</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Vybrať fotku"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"SIM karty"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"SIM karty"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<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="7900721153345139783">"SIM karty boli vymenené"</string>
    <string name="sim_cards_changed_message_summary" msgid="5452545583546944683">"Klepnutím nastavíte aktivity"</string>
    <string name="sim_cellular_data_unavailable" msgid="9018555543451203035">"Mobilné dáta nie sú k dispozícii"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="3654805961942166428">"Klepnutím vyberiete dátovú SIM kartu"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Vždy používať pre hovory"</string>
    <string name="select_sim_for_data" msgid="2366081042162853044">"Vyberte SIM kartu pre údaje"</string>
    <string name="data_switch_started" msgid="2040761479817166311">"Prepínajú sa dátové SIM karty, môže to chvíľu trvať..."</string>
    <string name="select_sim_for_calls" msgid="3503094771801109334">"Volať pomocou služby"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Výber SIM karty"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"SIM karta <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"SIM karta je prázdna"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Názov SIM karty"</string>
    <string name="sim_name_hint" msgid="7038643345238968930">"Zadajte názov SIM karty"</string>
    <string name="sim_editor_title" msgid="4034301817366627870">"Slot pre SIM kartu %1$d"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Operátor"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Číslo"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"Farba SIM karty"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"Vybrať SIM kartu"</string>
    <string name="color_orange" msgid="4417567658855022517">"Oranžová"</string>
    <string name="color_purple" msgid="3888532466427762504">"Purpurová"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"Nie sú vložené žiadne SIM karty"</string>
    <string name="sim_status_title" msgid="6744870675182447160">"Stav SIM karty"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Volať späť z predvolenej SIM karty"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"SIM karta pre odchádzajúce hovory"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Ďalšie nastavenia hovorov"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"Preferované zaťaž. siete"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Zakázať vysiel. názvu siete"</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"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="2252915199889604600">"Zakázaním vysielania názvu siete zabránite automatického pripojeniu ku skrytým sieťam."</string>
    <string name="sim_signal_strength" msgid="9144010043784767984">"<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="6272913297433198340">"SIM karty boli zmenené."</string>
    <string name="sim_notification_summary" msgid="5024470200658902406">"Nastavte klepnutím"</string>
    <string name="sim_pref_divider" msgid="6778907671867621874">"Preferovaná SIM karta pre"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="7941299533514115976">"Vždy sa opýtať"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Vyžaduje sa výber"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Nastavenia"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Nastavenia"</string>
    <string name="search_menu" msgid="7053532283559077164">"Hľadať"</string>
    <string name="query_hint_text" msgid="3350700807437473939">"Nastavenia vyhľadávania"</string>
    <string name="search_recents_queries_label" msgid="2128811638532309069">"Posledné vyhľadávania"</string>
    <string name="search_results_label" msgid="4163304782363526148">"Výsledky"</string>
    <string name="keywords_wifi" msgid="8947676711698613374">"wifi wi-fi sieť pripojenie"</string>
    <string name="keywords_more_default_sms_app" msgid="895656981962034647">"textová správa poslať správy SMS a MMS"</string>
    <string name="keywords_more_mobile_networks" msgid="4939725094449606744">"mobilný operátor mobilné dáta bezdrôtový prenos 4g 3g 2g lte"</string>
    <string name="keywords_home" msgid="3626170808219458848">"launcher"</string>
    <string name="keywords_display" msgid="6709007669501628320">"obrazovka dotyková obrazovka"</string>
    <string name="keywords_display_brightness_level" msgid="8923289340474728990">"stlmiť displej dotyková obrazovka batéria"</string>
    <string name="keywords_display_auto_brightness" msgid="8357056338746666901">"stlmiť displej dotyková obrazovka batéria"</string>
    <string name="keywords_display_night_mode" msgid="7652025075378505346">"tmavý motív nočný režim matná obrazovka invertovaný jas"</string>
    <string name="keywords_display_wallpaper" msgid="7778443098569037063">"pozadie personalizácia prispôsobenie displej"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"veľkosť textu"</string>
    <string name="keywords_display_cast_screen" msgid="8887412173792143329">"projekt"</string>
    <string name="keywords_storage" msgid="6572905220031852173">"miesto disk pevný disk zariadenie využitie"</string>
    <string name="keywords_battery" msgid="2096185085932675704">"využitie energie nabitia"</string>
    <string name="keywords_spell_checker" msgid="6106749039734174140">"pravopis slovník kontrola pravopisu automatické opravy"</string>
    <string name="keywords_voice_input" msgid="3519547605812413860">"rozpoznávač vstup reč hovoriť jazyk súprava hands-free hand free rozpoznávanie nevhodné slovo história zvuku bluetooth náhlavná súprava"</string>
    <string name="keywords_text_to_speech_output" msgid="392447904221657930">"sadzba jazyk predvolená reč hovoriť tts zjednodušenie ovládania čítačka slepota"</string>
    <string name="keywords_date_and_time" msgid="2631808108134830066">"hodiny čas"</string>
    <string name="keywords_factory_data_reset" msgid="4355133848707691977">"vymazať odstrániť obnoviť vymazanie odstránenie"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"tlačiareň"</string>
    <string name="keywords_sounds_and_notifications" msgid="5965996187974887000">"zvukový signál reproduktora"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="2912933812460077912">"nie nerušiť vyrušiť vyrušenie prestávka"</string>
    <string name="keywords_app" msgid="6334757056536837791">"RAM"</string>
    <string name="keywords_location" msgid="782326973714313480">"v blízkosti poloha história nahlasovanie"</string>
    <string name="keywords_location_mode" msgid="8584992704568356084">"presnosť"</string>
    <string name="keywords_accounts" msgid="1957925565953357627">"účet"</string>
    <string name="keywords_users" msgid="4673901601478559100">"obmedzenie obmedziť obmedzené"</string>
    <string name="keywords_keyboard_and_ime" msgid="5251531893531063855">"oprava textu opraviť zvuk vibrácie automatický výber jazyka návrh navrhovanie motív nevhodné slovo písanie emodži medzinárodné"</string>
    <string name="keywords_lockscreen" msgid="4806191868723291541">"prejsť prstom heslo vzor pin"</string>
    <string name="setup_wifi_nfc_tag" msgid="9028353016222911016">"Nastavenie značky NFC (Wi-Fi)"</string>
    <string name="write_tag" msgid="8571858602896222537">"Zapísať"</string>
    <string name="status_awaiting_tap" msgid="2130145523773160617">"Klepnutím na značku začnete zápis..."</string>
    <string name="status_invalid_password" msgid="2575271864572897406">"Neplatné heslo, skúste to znova."</string>
    <string name="status_write_success" msgid="5228419086308251169">"Podarilo sa!"</string>
    <string name="status_failed_to_write" msgid="8072752734686294718">"Zápis údajov na značku NFC sa nepodaril. Ak problém pretrváva, skúste inú značku."</string>
    <string name="status_tag_not_writable" msgid="2511611539977682175">"Na značku NFC sa nedá zapisovať. Použitie inú značku."</string>
    <string name="default_sound" msgid="8821684447333687810">"Predvolený zvuk"</string>
    <string name="notification_settings" msgid="8791730980212496561">"Zvuk a upozornenia"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Hlasitosť médií"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Hlasitosť budíkov"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Hlasitosť zvonenia"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Hlasitosť upozornení"</string>
    <string name="zen_mode_settings_title" msgid="7014915558669122902">"Vyrušenia"</string>
    <string name="zen_mode_option_title" msgid="5061978632306007914">"Pri prichádzajúcom hovore alebo upozornení"</string>
    <string name="zen_mode_option_off" msgid="3167702608910820883">"Vždy prerušiť"</string>
    <string name="zen_mode_option_important_interruptions" msgid="2320263300561981257">"Povoliť iba prioritné vyrušenia"</string>
    <string name="zen_mode_option_no_interruptions" msgid="5664234817617301449">"Neprerušovať"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Tón zvonenia telefónu"</string>
    <string name="notification_ringtone_title" msgid="3361201340352664272">"Predvolený tón upozornení"</string>
    <string name="vibrate_when_ringing_title" msgid="3806079144545849032">"Vibrovať aj pri hovoroch"</string>
    <string name="notification_section_header" msgid="95661783916799134">"Upozornenie"</string>
    <string name="notification_pulse_title" msgid="1247988024534030629">"Blikať kontrolkou upozornenia"</string>
    <string name="lock_screen_notifications_title" msgid="9118805570775519455">"Keď je zariadenie uzamknuté"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Zobraziť všetok obsah upozornení"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7891552853357258782">"Skryť citlivý obsah upozornení"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3001013816427963576">"Nezobrazovať upozornenia"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6164532459432182244">"Akým spôsobom chcete zobrazovať upozornenia na uzamknutom zariadení?"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Upozornenia aplikácií"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Iné zvuky"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Zvuky číselnej klávesnice"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Zvuky zámky obrazovky"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Zvuky doku"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Zvuky klepnutia"</string>
    <string name="vibrate_on_touch_title" msgid="674710566941697253">"Vibrovanie pri klepnutí"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Reproduktory doku"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Všetky zvukové súbory"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Iba zvukové médiá"</string>
    <string name="emergency_tone_silent" msgid="1067515631635824291">"Tichý režim"</string>
    <string name="emergency_tone_alert" msgid="8941852695428130667">"Upozornenie"</string>
    <string name="emergency_tone_vibrate" msgid="8281126443204950847">"Vibrovanie"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Prístup k upozorneniam"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Aplikácie nesmú čítať upozornenia"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="7930130030691218387">
      <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="no_notification_listeners" msgid="2767405417723149879">"Nie sú nainštalované žiadne aplikácie na počúvanie upozornení."</string>
    <string name="notification_listener_security_warning_title" msgid="6494221261778885893">"Povoliť službu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="2780319203595885564">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> bude môcť čítať všetky upozornenia, ktoré uverejní systém alebo ktorákoľvek z nainštalovaných aplikácií. Upozornenia môžu obsahovať osobné informácie, ako sú napríklad mená kontaktov alebo texty vám poslaných správ. Aplikácia bude tiež môcť tieto upozornenia zatvoriť alebo sa dotknúť tlačidiel akcií v upozorneniach."</string>
    <string name="manage_condition_providers" msgid="3039306415273606730">"Poskytovatelia podmienok"</string>
    <string name="manage_condition_providers_summary_zero" msgid="3760902189574984100">"Žiadne aplikácie neposkytujú podmienky"</string>
    <plurals name="manage_condition_providers_summary_nonzero" formatted="false" msgid="1398308139164964218">
      <item quantity="few">%d aplikácie poskytujú podmienky</item>
      <item quantity="many">%d aplikácie poskytuje podmienky</item>
      <item quantity="other">%d aplikácií poskytuje podmienky</item>
      <item quantity="one">%d aplikácia poskytuje podmienky</item>
    </plurals>
    <string name="no_condition_providers" msgid="6183782892066424125">"Nie sú nainštalovaní žiadni poskytovatelia podmienok."</string>
    <string name="condition_provider_security_warning_title" msgid="5834347345913614926">"Povoliť službu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="condition_provider_security_warning_summary" msgid="640037330610551763">"<xliff:g id="CONDITION_PROVIDER_NAME">%1$s</xliff:g> bude môcť pridávať podmienky ukončenia do režimu Nerušiť."</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Načítavajú sa aplikácie..."</string>
    <string name="app_notification_block_title" msgid="172237877395761371">"Blokovať"</string>
    <string name="app_notification_block_summary" msgid="9049487483231233726">"Nikdy nezobrazovať upozornenia z tejto aplikácie"</string>
    <string name="app_notification_priority_title" msgid="1967189807102076587">"Prioritné"</string>
    <string name="app_notification_priority_summary" msgid="7513344552201639232">"Zobrazovať upozornenia v hornej časti zoznamu a povoliť ich aj v prípade, keď sú na zariadení nastavené iba prioritné vyrušenia"</string>
    <string name="app_notification_sensitive_title" msgid="7707233094233553192">"Citlivé"</string>
    <string name="app_notification_sensitive_summary" msgid="2505314249332316395">"Skryť akýkoľvek citlivý obsah z upozornení tejto aplikácie v prípade, že je zariadenie uzamknuté"</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"Blokované"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Priorita"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Citlivé"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"Hotovo"</string>
    <string name="zen_mode_default_option" msgid="6940069025071935243">"Dokým túto funkciu nevypnete"</string>
    <string name="zen_mode_important_category" msgid="8123274463331022993">"Prioritné vyrušenia"</string>
    <string name="zen_mode_downtime_category" msgid="2654477732333340290">"Odstávka"</string>
    <string name="zen_mode_downtime_days" msgid="3361856902633311616">"Dni"</string>
    <string name="zen_mode_downtime_days_none" msgid="8454857121193391322">"Žiadne"</string>
    <string name="zen_mode_downtime_mode_title" msgid="7249388756365079715">"Prerušenia sú povolené"</string>
    <string name="zen_mode_downtime_mode_priority" msgid="1599184173608032994">"Iba prioritné"</string>
    <string name="zen_mode_downtime_mode_none" msgid="8572229891146527069">"Žiadna"</string>
    <string name="zen_mode_automation_category" msgid="4653551005950835761">"Automatizácia"</string>
    <string name="zen_mode_entry_conditions_title" msgid="8467976490601914289">"Automaticky zapnúť"</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="zen_mode_entry_conditions_summary_none" msgid="6589476427475076533">"Nikdy"</string>
    <string name="zen_mode_calls" msgid="7051492091133751208">"Hovory"</string>
    <string name="zen_mode_messages" msgid="5886440273537510894">"Správy"</string>
    <string name="zen_mode_from" msgid="1033337300289871697">"Hovory a správy od"</string>
    <string name="zen_mode_from_anyone" msgid="1180865188673992959">"Ktokoľvek"</string>
    <string name="zen_mode_from_contacts" msgid="8751503728985572786">"Iba kontakty"</string>
    <string name="zen_mode_from_starred" msgid="2168651127340381533">"Kontakty s hviezdičkou"</string>
    <string name="zen_mode_events" msgid="2456995649835437565">"Udalosti a pripomenutia"</string>
    <string name="zen_mode_alarm_info" msgid="3195430795475795398">"Budíky sú vždy považované za prioritné vyrušenia"</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Automaticky zapnúť"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Nikdy"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Každú noc"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Noci cez týždeň"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Čas začiatku"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Čas ukončenia"</string>
    <string name="zen_mode_end_time_priority_next_day_summary_format" msgid="2910982148167785730">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> nasledujúci deň"</string>
    <string name="zen_mode_end_time_none_same_day_summary_format" msgid="2002665300812473888">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> alebo ľubovoľný predchádzajúci budík"</string>
    <string name="zen_mode_end_time_none_next_day_summary_format" msgid="732719357166551378">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> nasledujúci deň alebo ľubovoľný predchádzajúci budík"</string>
    <string name="notification_settings_apps_title" msgid="1125354590652967250">"Upozornenia apl."</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Nastavenia upozornení"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Odoslať spätnú vazbu k tomuto zariadení"</string>
    <string name="restr_pin_enter_admin_pin" msgid="2451187374960131018">"Zadajte číslo PIN správcu"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Zapnuté"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Vypnuté"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Pripnutie k obrazovke"</string>
    <string name="screen_pinning_description" msgid="1137904524037468263">"Ak je toto nastavenie zapnuté, pomocou pripnutia k obrazovke môžete zaistiť zobrazenie aktuálnej obrazovky, dokým ju neuvoľníte.\n\nPostup pripnutia k obrazovke:\n\n1. Skontrolujte, či je funkcia pripnutia k obrazovke zapnutá.\n\n2. Otvorte obrazovku, ktorú chcete pripnúť.\n\n3. Klepnite na možnosť Prehľad.\n\n4. Prejdite prstom nahor a potom klepnite na ikonu špendlíka."</string>
    <string name="screen_pinning_unlock_pattern" msgid="8282268570060313339">"Pred uvoľnením požiadať o bezpečnostný vzor"</string>
    <string name="screen_pinning_unlock_pin" msgid="8757588350454795286">"Pred uvoľnením požiadať o číslo PIN"</string>
    <string name="screen_pinning_unlock_password" msgid="2514079566873826434">"Pred uvoľnením požiadať o heslo"</string>
    <string name="screen_pinning_unlock_none" msgid="3814188275713871856">"Uzamknúť zariadenie počas uvoľňovania"</string>
    <string name="managed_user_title" msgid="8101244883654409696">"Pracovný profil"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Experimentálne)"</string>
    <string name="display_auto_rotate_title" msgid="6176450657107806043">"Pri otáčaní zariadenia"</string>
    <string name="display_auto_rotate_rotate" msgid="4544299861233497728">"Otáčať obsah obrazovky"</string>
    <string name="display_auto_rotate_stay_in_portrait" msgid="292745182318093651">"Ponechať obrazovku v zobrazení na výšku"</string>
    <string name="display_auto_rotate_stay_in_landscape" msgid="3804752830204062162">"Ponechať obrazovku v zobrazení na šírku"</string>
    <string name="display_auto_rotate_stay_in_current" msgid="317932372686498096">"Ponechať obrazovku v súčasnej orentácii"</string>
    <string name="imei_information_title" msgid="8499085421609752290">"Informácie o kóde IMEI"</string>
    <string name="encryption_interstitial_header" msgid="5790264941172726485">"Šifrovanie"</string>
    <string name="encryption_continue_button" msgid="1121880322636992402">"Pokračovať"</string>
    <string name="encryption_interstitial_message_pin" msgid="3705622704667901162">"Ď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ť údaje na stratených alebo ukradnutých zariadeniach."</string>
    <string name="encryption_interstitial_message_pattern" msgid="2944051427890104942">"Ď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ť údaje na stratených alebo ukradnutých zariadeniach."</string>
    <string name="encryption_interstitial_message_password" msgid="1439296580879440802">"Ď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ť údaje na stratených alebo ukradnutých zariadeniach."</string>
    <string name="encrypt_require_pin" msgid="2063945047845243752">"Vyžadovať kód PIN na spustenie zariadenia"</string>
    <string name="encrypt_require_pattern" msgid="6898479411004015810">"Vyžadovať vzor na spustenie zariadenia"</string>
    <string name="encrypt_require_password" msgid="8770628366276570518">"Vyžadovať heslo na spustenie zariadenia"</string>
    <string name="encrypt_dont_require_pin" msgid="1082444817726247368">"Nie, vďaka"</string>
    <string name="encrypt_dont_require_pattern" msgid="6668299362640433843">"Nie, vďaka"</string>
    <string name="encrypt_dont_require_password" msgid="2580403214917009046">"Nie, vďaka"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"Vyžadovať kód PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"Vyžadovať vzor?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"Vyžadovať heslo?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="1890374082842868489">"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="4474332516537386384">"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="8166099418487083927">"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="imei_information_title" msgid="8499085421609752290">"Informácie o kóde IMEI"</string>
    <string name="imei_information_summary" msgid="2074095606556565233">"Informácie súvisiace s kódom IMEI"</string>
    <string name="slot_number" msgid="3762676044904653577">"(Slot <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="2184141780491382435">"Spúšťať ako predvolenú"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"V type úložiska <xliff:g id="STORAGE_TYPE">%2$s</xliff:g> je využité miesto s kapacitou <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="410824961149037234">"interná pamäť"</string>
    <string name="storage_type_external" msgid="8928374515368986503">"externá pamäť"</string>
    <string name="notifications_enabled" msgid="6983396130566021385">"Zapnuté"</string>
    <string name="notifications_disabled" msgid="4326096527874762629">"Blokované"</string>
    <string name="notifications_sensitive" msgid="3139432048186620878">"Citlivé"</string>
    <string name="notifications_priority" msgid="1812498477331421719">"Prioritné"</string>
    <string name="notifications_priority_sensitive" msgid="9011871917486793616">"Prioritné a citlivé"</string>
    <plurals name="permissions_summary" formatted="false" msgid="6402730318075959117">
      <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>
    <string name="launch_defaults_some" msgid="313159469856372621">"Je predvolená pre niektoré akcie"</string>
    <string name="launch_defaults_none" msgid="4241129108140034876">"Nie je predvolená pre žiadne akcie"</string>
</resources>
