<?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="device_info_default" msgid="7847265875578739287">"Neznáme"</string>
    <string name="header_category_wireless_networks" msgid="4944823405420438623">"BEZDRÔTOVÉ PRIPOJENIE A SIETE"</string>
    <string name="header_category_device" msgid="5781174212691167553">"ZARIADENIE"</string>
    <string name="header_category_personal" msgid="6225932173498802187">"OSOBNÉ"</string>
    <string name="header_category_system" msgid="2073558547468647128">"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="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="5874340256342956252">"(AC)"</string>
    <string name="battery_info_status_charging_usb" msgid="4059070156126770959">"(USB)"</string>
    <string name="battery_info_status_discharging" msgid="6222697503392774475">"Vybíjanie"</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_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_visibility" msgid="2930835434091839916">"Viditeľné"</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_not_discoverable" msgid="128269993123955177">"Prepne zariadenie do viditeľného režimu"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Časový limit viditeľnosti"</string>
    <string name="bluetooth_visibility_timeout_summary" msgid="6483353842671501585">"Nastavte dobu, počas ktorej bude zariadenie vo viditeľnom režime"</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" product="tablet" msgid="787970073150631155">"Premenovať tablet"</string>
    <string name="bluetooth_rename_device" product="default" msgid="6267987985556136749">"Premenovať telefón"</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_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" msgid="6038755206916626419">"Pripojené"</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_headset_no_a2dp" msgid="9195757766755553810">"Pripojené (bez telefónu alebo média)"</string>
    <string name="bluetooth_disconnected" msgid="6557104142667339895">"Odpojený"</string>
    <string name="bluetooth_disconnecting" msgid="8913264760027764974">"Prebieha odpájanie..."</string>
    <string name="bluetooth_connecting" msgid="8555009514614320497">"Prebieha pripájanie…"</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="8398232791303186677">"Výber zariadenia Bluetooth"</string>
    <string name="bluetooth_permission_request" msgid="1523129741266262748">"Žiadosť o povolenie zariadenia Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="5279027758886569301">"Aplikácia chce zapnúť pripojenie Bluetooth. Povoliť?"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="4420151924834278808">"Aplikácia v tablete chce prepnúť váš tablet do viditeľného režimu pre ostatné zariadenia Bluetooth na <xliff:g id="TIMEOUT">%1$d</xliff:g> sek. Povoliť?"</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="4478906085771274647">"Aplikácia v telefóne chce prepnúť váš telefón do viditeľného režimu pre ostatné zariadenia Bluetooth na <xliff:g id="TIMEOUT">%1$d</xliff:g> sek. Povoliť?"</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8737516188038252313">"Aplikácia v tablete chce prepnúť váš tablet do trvalo viditeľného režimu pre ostatné zariadenia Bluetooth. Povoliť?"</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="7751530664834149084">"Aplikácia v telefóne chce prepnúť váš telefón do trvalo viditeľného režimu pre ostatné zariadenia Bluetooth. Povoliť?"</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="8504403125440086020">"Aplikácia v tablete chce zapnúť pripojenie Bluetooth a prepnúť váš tablet do viditeľného režimu na <xliff:g id="TIMEOUT">%1$d</xliff:g> sek. Povoliť?"</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="3040361003987241057">"Aplikácia v telefóne chce zapnúť pripojenie Bluetooth a prepnúť váš telefón do viditeľného režimu na <xliff:g id="TIMEOUT">%1$d</xliff:g> sek. Povoliť?"</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="7254712987802497615">"Aplikácia v tablete chce zapnúť pripojenie Bluetooth a prepnúť váš tablet do viditeľného režimu. Povoliť?"</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="3947789545028519103">"Aplikácia v telefóne chce zapnúť pripojenie Bluetooth a prepnúť váš telefón do viditeľného režimu. Povoliť?"</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Zapnúť Bluetooth?"</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Vypínanie Bluetooth…"</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="457033227379858269">"Žiadosť telefónneho 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_pb_remember_choice" msgid="2901499974259177202">"Nabudúce sa nepýtať"</string>
    <string name="date_and_time" msgid="4114084177056654663">"Nastavenia dátumu a času"</string>
    <string name="date_time_12_hour_sample" msgid="3259617262618020574">"1:00 pop."</string>
    <string name="date_time_24_hour_sample" msgid="8916857570746212357">"13:00"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Zvoľte časové pásmo"</string>
    <string name="normal_date_format" msgid="7636406984925498359">"Miestne nastavenie (<xliff:g id="DATE">%s</xliff:g>)"</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="5912878565897294401">"Nastavenia servera 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="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_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="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="6889937359495515769">"Viac..."</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Bezdrôtové pripojenie a siete"</string>
    <string name="radio_controls_summary" msgid="2998818677094465517">"Spravovať Wi-Fi, Bluetooth, režim V lietadle, mobilné siete a siete VPN"</string>
    <string name="roaming" msgid="3596055926335478572">"Dátové služby pri roamingu"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Dátové služby sa môžu pripájať pri roamingu"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Dátové služby sa môžu pripojiť pri roamingu"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Pripojenie dátových služieb bolo prerušené, pretože ste opustili domovskú sieť a dátové služby pri roamingu máte vypnuté."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Zapnúť"</string>
    <string name="roaming_warning" msgid="7625933694709170887">"Ak povolíte dátové služby pri roamingu, môžu sa účtovať vysoké poplatky."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Povoliť dátové služby pri roamingu?"</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" msgid="1193032284921000063">"Použiť 24-hodinový formát"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Nastavenie času"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Voľba časového pásma"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Nastavenia dátumu"</string>
    <string name="date_time_date_format" msgid="6951498879879281102">"Vyberte formát 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="biometric_weak_improve_matching_title" msgid="8754080894393195194">"Zlepšiť priraďovanie tvárí"</string>
    <string name="biometric_weak_liveliness_title" msgid="2661613702124561096">"Kontrola živosti"</string>
    <string name="biometric_weak_liveliness_summary" msgid="4199587000948042325">"Pri odomykaní vyžadovať žmurknutie okom"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Automaticky uzamknúť"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po režime spánku"</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="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="location_settings_title" msgid="4483843407328665068">"Prístup k polohe"</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 ukladacieho priestoru poverení"</string>
    <string name="security_passwords_title" msgid="2930627259125138363">"Heslá"</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_encrypt_summary" product="tablet" msgid="6291564408810586">"Pri každom zapnutí tabletu požadovať číslo PIN alebo heslo na jeho dešifrovanie"</string>
    <string name="crypt_keeper_encrypt_summary" product="default" msgid="514138079795442371">"Pri každom zapnutí telefónu požadovať číslo PIN alebo heslo na jeho dešifrovanie"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Šifrované"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="3839235202103924154">"Svoje účty, nastavenia, prevzaté aplikácie a ich údaje môžete šifrovať. Po zašifrovaní tabletu budete musieť pri každom zapnutí zadať číselný kód PIN alebo heslo a dešifrovať ho – toto šifrovanie budete môcť zrušiť iba obnovením továrenských nastavení, čím sa všetky údaje v tablete vymažú."\n\n"Šifrovanie môže trvať aj viac ako hodinu. V tablete musí byť pred šifrovaním nabitá batéria a po celú dobu šifrovania musí byť pripojený k zdroju napájania. Ak šifrovanie prerušíte, stratíte niektoré alebo všetky údaje."</string>
    <string name="crypt_keeper_desc" product="default" msgid="7663118199519229502">"Svoje účty, nastavenia, prevzaté aplikácie a ich údaje môžete šifrovať. Po zašifrovaní telefónu budete musieť pri každom zapnutí zadať číselný kód PIN alebo heslo a dešifrovať ho – toto šifrovanie budete môcť zrušiť iba obnovením továrenských nastavení, čím sa všetky údaje v telefóne vymažú."\n\n"Šifrovanie môže trvať aj viac ako hodinu. V telefóne musí byť pred šifrovaním nabitá batéria a po celú dobu šifrovania musí byť pripojený k zdroju napájania. Ak šifrovanie prerušíte, stratíte niektoré alebo všetky ú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 číslo PIN na odomknutie obrazovky"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Pred spustením šifrovania musíte nastaviť heslo alebo kód PIN uzamknutia obrazovky."</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_cooldown" msgid="685210918307862395">"Počet sekúnd zostávajúcich do ďalšieho pokusu: <xliff:g id="DELAY">^1</xliff:g>."</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\n"Ak 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\n"Ak 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">"Zvoľte uzamk. obrazov."</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">"Uzamknutie 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="2871898266296656162">"Posunutie"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Bez zabezpečenia"</string>
    <string name="unlock_set_unlock_biometric_weak_title" msgid="2227215291604628670">"Odomknutie tvárou"</string>
    <string name="unlock_set_unlock_biometric_weak_summary" msgid="180083326982058964">"Nízka bezpečnosť, experimentálne"</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_set_unlock_disabled_summary" msgid="2120729867788851674">"Zakázané správcom, pravidlom šifrovania či uklad. priest. poverení"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Žiadne"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5660014471997663139">"Posunutie"</string>
    <string name="unlock_set_unlock_mode_biometric_weak" msgid="3008473624490350142">"Odomknutie tvárou"</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_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="2252847623267704683">"Kód PIN musí obsahovať najmenej %d znakov"</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">
    <item quantity="one" msgid="3063853802158131458">"Heslo musí obsahovať najmenej jedno písmeno."</item>
    <item quantity="other" msgid="8186027808415585970">"Heslo musí obsahovať najmenej %d písmen."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_lowercase">
    <item quantity="one" msgid="5583986519662091001">"Heslo musí obsahovať najmenej jedno malé písmeno."</item>
    <item quantity="other" msgid="2693910942679679225">"Heslo musí obsahovať najmenej %d malých písmen."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_uppercase">
    <item quantity="one" msgid="2611909966725502768">"Heslo musí obsahovať najmenej jedno veľké písmeno."</item>
    <item quantity="other" msgid="3030801209112209245">"Heslo musí obsahovať najmenej %d veľkých písmen."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_numeric">
    <item quantity="one" msgid="3820355568839621231">"Heslo musí obsahovať najmenej jednu číslicu."</item>
    <item quantity="other" msgid="4703982391407595924">"Heslo musí obsahovať najmenej %d číslic."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_symbols">
    <item quantity="one" msgid="8456579939292408631">"Heslo musí obsahovať najmenej jeden špeciálny symbol."</item>
    <item quantity="other" msgid="1221290525051187757">"Heslo musí obsahovať najmenej %d špeciálnych znakov."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_nonletter">
    <item quantity="one" msgid="4594051152085925921">"Heslo musí obsahovať najmenej jeden znak iný ako písmeno."</item>
    <item quantity="other" msgid="3952508584649046404">"Heslo musí obsahovať najmenej %d znakov iných ako písmená."</item>
  </plurals>
    <string name="lockpassword_password_recently_used" msgid="6098087796784262081">"Správca zariadení neumožňuje používanie nedávneho hesla."</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="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="5698297871117529185">"Ak chcete svoje zariadenie spárovať so zariadením <xliff:g id="BOLD_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>, zadajte kód PIN požadovaný zariadením:"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="2220143735340367939">"Ak chcete svoje zariadenie spárovať so zariadením <xliff:g id="BOLD_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>, zadajte tento prístupový kľúč vyžadovaný zariadením:"</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_accept" msgid="6163520056536604875">"Párovať"</string>
    <string name="bluetooth_pairing_decline" msgid="4185420413578948140">"Zrušiť"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_pairing_error_message" msgid="3748157733635947087">"Nepodarilo sa spárovať so zariadením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_pin_error_message" msgid="8337234855188925274">"Nepodarilo sa spárovať so zariadením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>, pretože ste zadali nesprávny kód PIN alebo prístupový kľúč."</string>
    <string name="bluetooth_pairing_device_down_error_message" msgid="7870998403045801381">"So zariadením <xliff:g id="DEVICE_NAME">%1$s</xliff:g> nie je možné komunikovať."</string>
    <string name="bluetooth_pairing_rejected_error_message" msgid="1648157108520832454">"Párovanie odmietnuté zariadením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</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="5957007154213560390">"Vyhľadáv. zariadení"</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_devices" msgid="1970524193086791964">"Párované zariadenia"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Dostupné 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="4793562956642282639">"Ak chcete zobraziť zariadenia, zapnite Bluetooth."</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Pripojiť k…"</string>
    <string name="bluetooth_profile_a2dp" msgid="2031475486179830674">"Zvuk medií"</string>
    <string name="bluetooth_profile_headset" msgid="8658779596261212609">"Zvuk telefónu"</string>
    <string name="bluetooth_profile_opp" msgid="9168139293654233697">"Prenos súborov"</string>
    <string name="bluetooth_profile_hid" msgid="3680729023366986480">"Vstupné zariadenie"</string>
    <string name="bluetooth_profile_pan" msgid="3391606497945147673">"Prístup na Internet"</string>
    <string name="bluetooth_profile_pan_nap" msgid="8429049285027482959">"Zdieľanie pripojenia na Internet"</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="3764437426089639639">"Profily"</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_a2dp_profile_summary_connected" msgid="963376081347721598">"Pripojené ku zvukovému médiu"</string>
    <string name="bluetooth_headset_profile_summary_connected" msgid="7661070206715520671">"Pripojené ku zvuku telefónu"</string>
    <string name="bluetooth_opp_profile_summary_connected" msgid="2611913495968309066">"Pripojené na server pre prenos údajov"</string>
    <string name="bluetooth_opp_profile_summary_not_connected" msgid="1267091356089086285">"Nepripojené k serveru pre prenos súborov"</string>
    <string name="bluetooth_hid_profile_summary_connected" msgid="3381760054215168689">"Pripojené na vstupné zariadenie"</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_a2dp_profile_summary_use_for" msgid="4630849022250168427">"Umožňuje pripojenie zvukového média"</string>
    <string name="bluetooth_headset_profile_summary_use_for" msgid="8705753622443862627">"Použiť pre zvuk telefónu"</string>
    <string name="bluetooth_opp_profile_summary_use_for" msgid="1255674547144769756">"Použiť na prenos súborov"</string>
    <string name="bluetooth_hid_profile_summary_use_for" msgid="232727040453645139">"Použiť pre vstup"</string>
    <string name="bluetooth_pan_profile_summary_use_for" msgid="5664884523822068653">"Použiť na prístup k Internetu"</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="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\n"Stačí 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="874495178395350104">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="1047950931623694366">"Zapnúť Wi-Fi"</string>
    <string name="wifi_settings" msgid="1277428034634973011">"Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="2810363951104753710">"Nastavenia Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="4351120897298124250">"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="70277346338812325">"Vybrať sieť Wi-Fi"</string>
    <string name="wifi_starting" msgid="6716593470710880000">"Zapnúť Wi-Fi?"</string>
    <string name="wifi_stopping" msgid="244864762599017659">"Prebieha vypínanie siete 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_fail_to_scan" msgid="1265540342578081461">"Siete sa nedajú vyhľadávať"</string>
    <string name="wifi_notify_open_networks" msgid="3755768188029653293">"Upozornenie na sieť"</string>
    <string name="wifi_notify_open_networks_summary" msgid="3038290727701553612">"Oznamovať dostupné nezabezpečené siete"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Vyhnúť sa nekvalitným pripojeniam"</string>
    <string name="wifi_poor_network_detection_summary" msgid="2466956369738047669">"Nepoužívať sieť Wi-Fi, pokiaľ nemá dostatočne kvalitné internetové pripojenie"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="9107237003911220057">"Ponechať pripojenie Wi-Fi zapnuté 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_add_network" msgid="6234851776910938957">"Pridať sieť"</string>
    <string name="wifi_access_points" msgid="2664629396767022441">"Siete Wi-Fi"</string>
    <string name="wifi_menu_wps_pbc" msgid="2668564692207863017">"Tlačidlo WPS"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"Zadanie kódu WPS PIN"</string>
    <string name="wifi_menu_p2p" msgid="2575893749303670353">"Priame prip. Wi-Fi"</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_connect" msgid="4996220309848349408">"Pripojiť k sieti"</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_empty_list_wifi_off" msgid="4722299515264875943">"Ak chcete zobraziť dostupné siete, zapnite sieť Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="3354911729026237372">"Prebieha vyhľadávanie sietí Wi-Fi..."</string>
    <string name="wifi_other_network" msgid="1048006316504242214">"Iná sieť..."</string>
    <string name="wifi_more" msgid="3195296805089107950">"Viac"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Automatické nastavenie (WPS)"</string>
    <string name="wifi_show_advanced" msgid="1793703023711426246">"Zobraziť rozšírené možnosti"</string>
    <string name="wifi_wps_setup_title" msgid="6034518116333042484">"Zabezpečené nastavenie siete Wi-Fi"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"Spúšťanie WPS…"</string>
    <string name="wifi_wps_onstart_pbc" msgid="7204827509934892103">"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="8116564886303972764">"Zadajte vo 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="5754399645462924103">"Pripojené k sieti Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_wps_in_progress" msgid="2944576520214787628">"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="641393708309146745">"Identifikátor SSID siete"</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_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_remembered" msgid="4955746899347821096">"Uložené"</string>
    <string name="wifi_disabled_generic" msgid="4259794910584943386">"Zakázané"</string>
    <string name="wifi_disabled_network_failure" msgid="3111321240793227690">"Bolo zabránené slabému internetovému pripojeniu"</string>
    <string name="wifi_disabled_password_failure" msgid="8659805351763133575">"Problém s overením totožnosti"</string>
    <string name="wifi_not_in_range" msgid="1136191511238508967">"Mimo dosah"</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_secured_first_item" msgid="4072076186051083451">"Zabezpečenie: <xliff:g id="WIFI_SECURITY_SHORT">%1$s</xliff:g>"</string>
    <string name="wifi_secured_second_item" msgid="1326000076939056265">", zabezpečenie: <xliff:g id="WIFI_SECURITY_SHORT">%1$s</xliff:g>"</string>
    <string name="wifi_security_none" msgid="7985461072596594400">"Žiadne"</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_advanced_titlebar" msgid="1627063574532930090">"Rozšírené nastavenia Wi-Fi"</string>
    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"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_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="400503541488064638">"Priame pripojenie Wi-Fi"</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_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_tether_checkbox_text" msgid="6961605862058056788">"Prenosný prístupový bod Wi-Fi"</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="2654888578056042315">"Chyba prenosného prístupového bodu Wi-Fi"</string>
    <string name="wifi_tether_configure_ap_text" msgid="61237027772641155">"Nastaviť hotspot Wi-Fi"</string>
    <string name="wifi_tether_configure_subtext" msgid="1927454307836232128">"Prenosný prístupový bod 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="display_settings_title" msgid="1708697328627382561">"Zobraziť"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Zvuk"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Vyzváňací tón telefónu"</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="312032901303146002">"Predvolené upozornenie"</string>
    <string name="notification_pulse_title" msgid="1247988024534030629">"Blikať kontrolkou upozornenia"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Vyzváňací tón"</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="notification_sound_dialog_title" msgid="9052854168612951170">"Zvoliť vyzváňací tón upozornenia"</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 na číselnú klávesnicu"</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="vibrate_when_ringing_title" msgid="3885857358303178029">"Vibrovať pri zvonení"</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="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">"Automatické otočenie obrazovky"</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="2354961343555249270">"Jas"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Nastavenia jasu obrazovky"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Režim spánku"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Po <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="3848608373818910549">"Dekorácia obrazovky"</string>
    <string name="screensaver_settings_summary_on" msgid="433728808047613634">"Ak je zariadenie pripojené ku zdroju, spustí sa pri prechode do režimu spánku"</string>
    <string name="screensaver_settings_summary_off" msgid="7019248565878953105">"Zakázané"</string>
    <string name="screensaver_component_title" msgid="8596216100441725363">"Vybratá dekorácia"</string>
    <string name="screensaver_timeout_title" msgid="4882666970355550822">"Čas aktivácie"</string>
    <string name="screensaver_timeout_summary" msgid="7717201094598701673">"Po nečinnosti <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g>"</string>
    <string name="screensaver_timeout_zero_summary" msgid="1274235565189071582">"Nikdy"</string>
    <string name="screensaver_test" msgid="3048249263811694128">"Vyskúšať"</string>
    <string name="screensaver_activate_on_dock_title" msgid="3753003388633168862">"Spustiť aj po vložení do doku"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Automatický jas"</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">"Ak chcete použiť tablet, musíte zadať kód PIN"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Ak chcete telefón použiť, musíte zadať kód PIN"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Ak chcete použiť tablet, musíte zadať kód PIN"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Ak chcete telefón použiť, musíte zadať kód PIN"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Zmeniť kód 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="3178510434642201544">"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ť."\n"Kó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ť."\n"Zrejme 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="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="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">"Ukladací priestor"</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="3279383550222116235">"Typ mobilnej siete"</string>
    <string name="status_data_state" msgid="5503181397066522950">"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="33109409206264790">"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_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">"Prevzatia"</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="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="read_only" msgid="6702420168629076340">" (Iba na čítanie)"</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_label_installer_cd" msgid="4331173824920630215">"Inštalovať nástroje na prenos súborov"</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="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="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_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">"Vymazať všetky vaše osobné údaje a prevzaté 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_prompt" msgid="1428645764883536750">"Nakreslite bezpečnostný vzor"</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="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_prompt" msgid="3109349468816856670">"Nakreslite bezpečnostný vzor"</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_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" 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="7967552516440151852">"Mobilné siete"</string>
    <string name="location_title" msgid="1029961368397484576">"Moja poloha"</string>
    <string name="location_network_based" msgid="7472814266821714527">"Poloha Wi-Fi a mobilnej 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="7457348712272184793">"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="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="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">"Vyberte vzor"</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">"Potvrďte vzor"</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">"Odomknúť výber"</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úsiť 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="4622772178078818425">"Na záver zdvihnite prst z obrazovky."</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3103250430366718996">"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="8378617839439987962">"Vzor bol zaznamenaný."</string>
    <string name="lockpattern_need_to_confirm" msgid="5144676887162575050">"Znova nakreslite bezpečnostný vzor pre potvrdenie:"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2223856038485537716">"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">"Zobraziť 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">"Tlačidlo napáj. ihneď zamkne"</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="skip_button_label" msgid="8680422740354436943">"Zrušiť"</string>
    <string name="next_button_label" msgid="8890792540116568321">"Ďalej"</string>
    <string name="lock_title" product="tablet" msgid="2909697418179419990">"Zabezpečenie vášho tabletu"</string>
    <string name="lock_title" product="default" msgid="4059246467204273930">"Zabezpečenie telefónu"</string>
    <string name="lock_intro_message" product="tablet" msgid="8616353869251700776">"Chráňte svoj tablet pred neoprávneným použitím vytvorením osobného vzoru na odomknutie obrazovky. Na ďalšej obrazovke pospájajte prstom body v ľubovoľnom poradí. Musíte spojiť aspoň štyri body. "\n\n"Ak chcete začať, dotknite sa tlačidla Ďalej."</string>
    <string name="lock_intro_message" product="default" msgid="8393155371327584659">"Svoj telefón môžete chrániť pred neautorizovaným použitím pomocou osobného bezpečnostného vzoru obrazovky. Bodky na nasledujúcej obrazovke spojte prejdením prstom v akomkoľvek poradí. Spojiť treba aspoň štyri bodky. "\n\n"Keď chcete začať, dotknite sa tlačidla „Ďalej“."</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_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 ste výhradne zodpovedný/-á 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 ste výhradne zodpovedný/-á 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">"Ukladací priestor"</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="disable_text" msgid="6544054052049395202">"Zakázať"</string>
    <string name="enable_text" msgid="9217362512327828987">"Povoliť"</string>
    <string name="clear_user_data_text" msgid="5597622864770098388">"Vymazanie údajov"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Odinštalácia aktualizácií"</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="1118129530999596317">"Touto akciou obnovíte všetky predvoľby pre:"\n\n" "<li>"zakázané aplikácie,"</li>\n" "<li>"zakázané upozornenia aplikácií,"</li>\n" "<li>"predvolené aplikácie na vykonávanie akcií,"</li>\n" "<li>"obmedzenia údajov na pozadí pre aplikácie."</li>\n\n" O žiadne údaje aplikácií neprídete."</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_third_party" msgid="7786348047690140979">"Prevzaté"</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="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ácií?"</string>
    <string name="clear_data_dlg_text" msgid="8847257251846779938">"Všetky údaje tejto aplikácie (všetky súbory, nastavenia, účty, databázy a pod.) 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">"Vymazanie údajov"</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="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_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="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_processes_item_description_s_s" msgid="5790575965282023145">"Počet procesov: <xliff:g id="NUMPROCESS">%1$d</xliff:g>; počet služieb: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"Počet procesov: <xliff:g id="NUMPROCESS">%1$d</xliff:g>; počet služieb: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"Počet procesov: <xliff:g id="NUMPROCESS">%1$d</xliff:g>; počet služieb: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"Počet procesov: <xliff:g id="NUMPROCESS">%1$d</xliff:g>; počet služieb: <xliff:g id="NUMSERVICES">%2$d</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">"Zobraziť heslá"</string>
    <string name="show_password_summary" msgid="7345931695292850058"></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_titlebar" msgid="765659257455000490">"Používateľský slovník"</string>
    <string name="user_dict_single_settings_title" msgid="524997218433540614">"Osobný slovník"</string>
    <string name="user_dict_multiple_settings_title" msgid="3735224433307996276">"Osobné slovníky"</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_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="quick_launch_title" msgid="7904609846945905306">"Rýchle spustenie"</string>
    <string name="quick_launch_summary" msgid="8101133819188001190">"Nastavenie klávesových skratiek na spúšťanie aplikácií"</string>
    <string name="quick_launch_assign_application" msgid="6240064079456617501">"Priradiť aplikáciu"</string>
    <string name="quick_launch_no_shortcut" msgid="5998005833838278693">"Žiadna klávesová skratka"</string>
    <string name="quick_launch_shortcut" msgid="5090405067413522300">"Hľadať + <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g>"</string>
    <string name="quick_launch_clear_dialog_title" msgid="5546543501250320220">"Vymazať"</string>
    <string name="quick_launch_clear_dialog_message" msgid="3921015601470260722">"Klávesová skratka <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g> (<xliff:g id="APPLICATION_NAME">%2$s</xliff:g>) bude vymazaná."</string>
    <string name="quick_launch_clear_ok_button" msgid="2634568926597586716">"OK"</string>
    <string name="quick_launch_clear_cancel_button" msgid="1892854652197747064">"Zrušiť"</string>
    <string name="quick_launch_display_mode_applications" msgid="1734058461846126775">"Aplikácie"</string>
    <string name="quick_launch_display_mode_shortcuts" msgid="4177934019174169042">"Odkazy"</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="234072873286056438">"Predvolená hodnota"</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="enable_adb" msgid="7982306934419797485">"Ladenie USB"</string>
    <string name="enable_adb_summary" msgid="4881186971746056635">"Povoliť režim ladenia s pripojeným zariadením USB"</string>
    <string name="keep_screen_on" msgid="1146389631208760344">"Nezamykať obrazovku"</string>
    <string name="keep_screen_on_summary" msgid="2173114350754293009">"Obrazovka sa pri nabíjaní neprepne do režimu spánku"</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="adb_warning_title" msgid="6234463310896563253">"Povoliť ladenie USB?"</string>
    <string name="adb_warning_message" msgid="7316799925425402244">"Ladenie USB je určené iba na účely vývoja. Použite ho na kopírovanie údajov medzi počítačom a zariadením, inštaláciu aplikácií do zariadenia bez upozornenia a čítanie údajov denníka."</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="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\n"Pri 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\n"Pri niektorých aplikáciách platí, že budú fungovať až vtedy, keď ich vývojári aktualizujú."</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="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="launch_count_label" msgid="4019444833263957024">"Súčet"</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_toggle_large_text_title" msgid="6618674985313017711">"Veľké písmo"</string>
    <string name="accessibility_power_button_ends_call_title" msgid="5468375366375940894">"Tlačidlo Napájanie ukončuje hovor"</string>
    <string name="accessibility_speak_password_title" msgid="3344423945644925355">"Hovorené heslá"</string>
    <string name="accessibility_long_press_timeout_title" msgid="2373216941395035306">"Oneskorenie dotyku a podržania"</string>
    <string name="accessibility_script_injection_title" msgid="7921388904564822855">"Zlepšiť dostupnosť webu"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Nastavenia"</string>
    <string name="accessibility_service_state_on" msgid="8791337599927106344">"Zapnuté"</string>
    <string name="accessibility_service_state_off" msgid="2458594460762620776">"Vypnuté"</string>
    <string name="accessibility_script_injection_allowed" msgid="7624804397748427621">"Povolené"</string>
    <string name="accessibility_script_injection_disallowed" msgid="8639525487720429182">"Nie je povolené"</string>
    <string name="accessibility_script_injection_button_allow" msgid="2201503285877102870">"Povoliť"</string>
    <string name="accessibility_script_injection_button_disallow" msgid="5697152768523270885">"Nepovoliť"</string>
    <string name="accessibility_service_security_warning_title" msgid="5421628151509995404">"Použiť službu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_service_security_warning_summary" product="tablet" msgid="8558441850832543571">"Služba na zjednodušenie ovládania <xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> zaznamenáva všetok text, ktorý napíšete, okrem hesiel. To zahŕňa osobné údaje, ako sú čísla kreditných kariet. Zaznamenáva aj údaje o interakcii so zariadením."</string>
    <string name="accessibility_service_security_warning_summary" product="default" msgid="2869015914319424723">"Služba na zjednodušenie ovládania <xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> zaznamenáva všetok text, ktorý napíšete, okrem hesiel. To zahŕňa osobné údaje, ako sú čísla kreditných kariet. Zaznamenáva aj údaje o využívaní telefónu."</string>
    <string name="accessibility_service_disable_warning_title" msgid="3393956845814484859">"Zastaviť službu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_service_disable_warning_summary" msgid="625013894287895398">"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_no_apps_title" msgid="5124097563864109821">"Potrebujete čítačku obrazovky?"</string>
    <string name="accessibility_service_no_apps_message" msgid="7751662416377046539">"Aplikácia Talkback poskytuje hovorenú odozvu na pomoc nevidomým a slabozrakým používateľom. Chcete si túto aplikáciu bezplatne nainštalovať zo služby Android Market?"</string>
    <string name="accessibility_script_injection_security_warning_summary" msgid="7706858873495386310">"Chcete, aby aplikácie prevzali zo služby Google skripty, ktoré uľahčia prístup k ich obsahu?"</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="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="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">"Doba prevádzky na batérii: <xliff:g id="TIME">%1$s</xliff:g>"</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="3093545080361658269">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Prebudiť"</string>
    <string name="battery_stats_phone_signal_label" msgid="4137799310329041341">"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="6310209835617490616">"Doba prevádzky siete Wi-Fi"</string>
    <string name="bluetooth_on_time" msgid="6157799524996162271">"Doba prevádzky siete Wi-Fi"</string>
    <string name="usage_name_percent" msgid="7976919382448235858">"<xliff:g id="NAME">%1$s</xliff:g> – <xliff:g id="NUMBER">%2$s</xliff:g> <xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="history_details_title" msgid="3608240585315506067">"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_wifi" msgid="2382791137776486974">"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="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="8234997940652067049">"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="2857401966985425427">"Odoslané údaje"</string>
    <string name="usage_type_data_recv" msgid="7251090882025234185">"Prijaté údaje"</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="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="2272741639606146903">"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_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="1702486494565080431">"Využitie batérie sieťou Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="2085605314976704287">"Vypnite pripojenie Wi-Fi, keď sa 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="7287643439298561315">"GPS môžete ručne nastaviť tak, aby ho aplikácie nemohli používať"</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="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="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="recognizer_title" msgid="3231385184559054457">"Rozpoznávanie hlasu"</string>
    <string name="recognizer_settings_title" msgid="432493301215113154">"Hlasové vyhľadávanie"</string>
    <string name="recognizer_settings_summary" msgid="4472287934134546902">"Nastavenia modulu gadget „<xliff:g id="RECOGNIZER_NAME">%s</xliff:g>“"</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="6482936537135251690">"Umožňuje nastaviť nástroj na syntézu reči použitý pre hovorený text"</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_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_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="2382963973155082629">"Prebieha aktualizácia nastavenia Wi-Fi"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Prebieha aktualizácia nastavenia Bluetooth"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Ukladací priestor poverení"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Inštalovať z uklad. priestoru"</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 ukladacieho priestoru"</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="credentials_install_gesture_prompt" msgid="2207390278112395082">"Nakreslite bezpečnostný vzor"</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 ukladacieho priestoru 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 ukladacieho priestoru poverení: <xliff:g id="NUMBER">%1$d</xliff:g>."</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Ukl. priestor pover. je vymaz."</string>
    <string name="credentials_not_erased" msgid="93461830775441220">"Úložisko poverení nemožno vym."</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Ukladací priestor poverení je aktivovaný."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="6757119179588664966">"Pred použitím úložiska poverení musíte nastaviť heslo alebo kód PIN uzamknutia obrazovky."</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álohovať a obnoviť"</string>
    <string name="privacy_settings_title" msgid="4856282165773594890">"Zálohovať a obnoviť"</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="9157861529438245957">"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="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="bugreport_title" msgid="1009498799922543551">"Zaznamenať správu o chybe"</string>
    <string name="bugreport_message" msgid="1182209569732110590">"Zhromažďuje informácie o aktuálnom stave zariadenia a tieto informácie je následne možné odoslať prostredníctvom e-mailovej správy. Od spustenia vytvárania správy o chybe až do chvíle, kedy je tento nástroj pripravený odoslať prvú správu, môže uplynúť nejaký čas. Prosíme vás preto o trpezlivosť."</string>
    <string name="report" msgid="302437572240018342">"Vytvoriť prehľad"</string>
    <string name="local_backup_password_title" msgid="3860471654439418822">"Heslo pre zálohu do PC"</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="7218566008912418809">"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="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="untitled_apn" msgid="1230060359198685513">"Bez názvu"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Všeobecné"</string>
    <string name="sound_category_notification_title" msgid="3502115998790286943">"Upozornenia"</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="661074868726906436">"Nastavenie Wi-Fi"</string>
    <string name="wifi_setup_title_editing_network" msgid="7304321031985059969">"Pripojiť k sieti Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_connecting_network" msgid="3747859666621319757">"Prebieha pripájanie k sieti Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>..."</string>
    <string name="wifi_setup_title_connected_network" msgid="209755856836003839">"Pripojené k sieti Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Pridať sieť"</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="595556546597351489">"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 Nastaveniach &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="5235991893829582459">"Ak chcete pokračovať v nastavovaní, dotknite sa možnosti "<b>"Ďalej"</b>"."\n\n"Ak 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_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="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>" "\n"Spoloč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" product="tablet" msgid="3086620478225952725">"Niektoré aplikácie vyžadujú tento účet. Odstrániť ich môžete obnovením tabletu na predvolené továrenské nastavenia (čím odstránite všetky vaše osobné údaje) v časti Nastavenia &gt; Zálohovať a obnoviť."</string>
    <string name="remove_account_failed" product="default" msgid="6217238709175617517">"Tento účet je vyžadovaný niektorými aplikáciami. Môžete ho odstrániť iba obnovením telefónu na predvolené továrenské nastavenia (čím odstránite všetky vaše osobné údaje) v časti Nastavenia &gt; Zálohovať a obnoviť."</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="1574837328738396794">"Nastavenia 4G"</string>
    <string name="wimax_settings_summary" msgid="3207355006084135453">"Nastaviť a spravovať sieť 4G a modem"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"Adresa 4G MAC"</string>
    <string name="enter_password" msgid="4131758584074246224">"Ak chcete dešifrovať ukladací priestor, zadajte heslo"</string>
    <string name="try_again" msgid="4272075051293936921">"Skúsiť znova."</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">"Apl. na ladenie čaká na pripojenie lad. nástroja"</string>
    <string name="debug_input_category" msgid="1811069939601180246">"Vstup"</string>
    <string name="debug_drawing_category" msgid="6755716469267367852">"Kresba"</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">"Blikanie 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">"Prekryvná vrstva s aktuálnymi údajmi o dotykoch"</string>
    <string name="show_touches" msgid="1356420386500834339">"Zobraziť dotyky"</string>
    <string name="show_touches_summary" msgid="6684407913145150041">"Zobraziť vizuálnu spätnú väzbu pre dotyky"</string>
    <string name="show_screen_updates" msgid="5470814345876056420">"Zobraziť aktual. obsahu"</string>
    <string name="show_screen_updates_summary" msgid="2569622766672785529">"Celý obsah okna pri aktualizácii bliká"</string>
    <string name="show_hw_screen_updates" msgid="5036904558145941590">"Zobr. aktual. zobraz. GPU"</string>
    <string name="show_hw_screen_updates_summary" msgid="1115593565980196197">"Zobrazenia v oknách vykresľované s GPU blikajú"</string>
    <string name="disable_overlays" msgid="2074488440505934665">"Zakázať hardvér. prekrytia"</string>
    <string name="disable_overlays_summary" msgid="3578941133710758592">"Vždy používať jednotku GPU na skladanie obrazovky"</string>
    <string name="enable_traces_title" msgid="7448835465859512430">"Povoliť sledovania"</string>
    <string name="enable_traces_dialog_title" msgid="5026490474669452929">"Vybrať povolené sledovania"</string>
    <string name="enable_traces_summary_none" msgid="1867562808503494163">"Momentálne nie sú povolené žiadne sledovania"</string>
    <string name="enable_traces_summary_num" msgid="8978230237777454269">"Počet aktuálne povolených sledovaní: <xliff:g id="NUM">%1$d</xliff:g>"</string>
    <string name="enable_traces_summary_all" msgid="3950139649125158247">"Všetky sledovania sú v súčasnosti povolené"</string>
    <string name="debug_layout" msgid="5981361776594526155">"Zobraziť hranice rozlož."</string>
    <string name="debug_layout_summary" msgid="2001775315258637682">"Zobraziť v klipe ohraničenie, okraje a pod."</string>
    <string name="show_cpu_usage" msgid="2389212910758076024">"Zobraziť využitie CPU"</string>
    <string name="show_cpu_usage_summary" msgid="2113341923988958266">"Prekryvná vrstva obr. s aktuálnym využ. procesora"</string>
    <string name="force_hw_ui" msgid="6426383462520888732">"Vynútiť vykresľovanie GPU"</string>
    <string name="force_hw_ui_summary" msgid="5535991166074861515">"Vynútiť použitie jednotky GPU na vykresľovanie 2D"</string>
    <string name="track_frame_time" msgid="6146354853663863443">"Profilové vykresľ. GPU"</string>
    <string name="track_frame_time_summary" msgid="447577515813970287">"Merať čas vykresľov. v adb shell dumpsys gfxinfo"</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="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">"Zobraziť všetky ANR"</string>
    <string name="show_all_anrs_summary" msgid="641908614413544127">"Zobraziť dialógové okno Aplikácia neodpovedá (ANR) pre aplikácie na pozadí"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Využitie dát"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Cyklus počítania dát"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Dátové služby pri roamingu"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Obmedzenie dátových prenosov 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="8266875319417201085">"Zobraziť 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_metered" msgid="5056695223222541863">"Mobilné hotspoty"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Automatická synchronizácia ú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="5211007048880167438">"Zakázať mobilné dáta?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Nastaviť dát. limit mobil. sietí"</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="8575537650560665657">"Nastaviť dát. limit sietí Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="1728851922959017766">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="454140350007299045">"Mobil"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="5588685410495019866">"Mobil"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Žiadne"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"Mobilné dátové prenosy"</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_app_settings" msgid="8430240158135453271">"Zobraziť nastavenia aplikácie"</string>
    <string name="data_usage_app_restrict_background" msgid="9149728936265100841">"Obmedzenie dátových prenosov na pozadí"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="518658001418490405">"Zakázať údaje na pozadí v mob. sieťach. Použiť iné ako mob. siete, ak sú k disp."</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"Nastav. dát. limitu mob. siete obmedzíte údaje na poz. pre apl."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Obmedziť údaje na pozadí?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="1466689968707308512">"Ak budú k dispozícii len mobilné siete, môže táto funkcia spôsobiť, že aplikácie, ktoré údaje na pozadí vyžadujú, nebudú fungovať."\n\n"Vhodnejšie spôsoby ovládania využívania údajov nájdete v nastaveniach aplikácie."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="7086969103661420799">"Obmedzenie údajov na pozadí je možné len v prípade, že ste nastavili dátový limit pre mobilnú sieť."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Zapnúť automat. synchr. údajov?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="7312283529426636845">"Všetky zmeny vykonané v rámci vašich účtov na webe sa automaticky skopírujú do vášho tabletu."\n\n"Niektoré účty môžu tiež automaticky skopírovať na web akékoľvek zmeny vykonané v tablete. Týmto spôsobom funguje aj účet Google."\n\n"Typy informácií, ktoré sa budú v jednotlivých účtoch synchronizovať, môžete nastaviť v sekcii Nastavenia &gt; Účty."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="2374996799819303283">"Všetky zmeny vykonané v rámci vašich účtov na webe sa automaticky skopírujú do vášho telefónu."\n\n"Niektoré účty môžu tiež automaticky skopírovať na web akékoľvek zmeny vykonané v telefóne. Týmto spôsobom funguje aj účet Google."\n\n"Typy informácií, ktoré sa budú v jednotlivých účtoch synchronizovať, môžete nastaviť v sekcii Nastavenia &gt; Účty."</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="3893348029612821262">"Po dosiahnutí stanoveného limitu bude vaše mobilné dátové pripojenie zakázané."\n\n"Keďže sa využitie dát meria pomocou vášho tabletu a operátor môže využitie dát účtovať inak, zvážte nastavenie nižšieho limitu."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="7962145861903746827">"Po dosiahnutí stanoveného limitu bude vaše mobilné dátové pripojenie zakázané."\n\n"Keďže sa využitie dát meria pomocou vášho telefónu a operátor môže využitie dát účtovať inak, zvážte nastavenie nižšieho limitu."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Obmedziť údaje na pozadí?"</string>
    <string name="data_usage_restrict_background" msgid="6387252645350792955">"Ak obmedzíte mobilné údaje na pozadí, niektoré aplikácie a služby nebudú fungovať, pokiaľ nebudete mať pripojenie k sieti Wi-Fi."</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_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="6204750602856383278">"Mobilné hotspoty"</string>
    <string name="data_usage_metered_body" msgid="2446827764036316131">"Vyberte siete Wi-Fi, ktoré sú mobilnými hotspotmi. Aplikáciám na pozadí môže byť používanie týchto sietí zakázané. Aplikácie môžu tiež pred preberaním veľkých súborov pomocou týchto sietí zobraziť upozornenie."</string>
    <string name="data_usage_metered_mobile" msgid="5423305619126978393">"Mobilné siete"</string>
    <string name="data_usage_metered_wifi" msgid="4151511616349458705">"Siete Wi-Fi"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="7566012564261138417">"Ak chcete vybrať mobilné hotspoty, zapnite pripojenie k sieti  Wi-Fi."</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_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="percentage" msgid="5866131581207788624">"<xliff:g id="NUMBER">%d</xliff:g> %%"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Ďalšie aktualizácie systému"</string>
    <string name="user_settings_title" msgid="5189224330534906766">"Používatelia a obmedzenia"</string>
    <string name="user_list_title" msgid="2152311434413878709">"Používatelia"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Pridať používateľa"</string>
    <string name="user_details_title" msgid="3037625632127241370">"Upraviť podrobnosti"</string>
    <string name="user_information_heading" msgid="8728151075759863162">"Informácie o používateľovi"</string>
    <string name="user_name_title" msgid="7563724675699398319">"Meno"</string>
    <string name="user_restrictions_heading" msgid="4426403050397418553">"Obmedzenia obsahu"</string>
    <string name="user_market_requires_pin" msgid="3260702297207279414">"Vyžadovať PIN"</string>
    <string name="user_max_content_rating" msgid="8297759970216482772">"Hodnotenie obsahu"</string>
    <string name="user_system_apps_heading" msgid="2408331798732183682">"Systémové aplikácie"</string>
    <string name="user_market_apps_heading" msgid="4657387297168308251">"Nainštalované aplikácie"</string>
    <string name="user_discard_user_menu" msgid="6638388031088461242">"Zahodiť"</string>
    <string name="user_remove_user_menu" msgid="3210146886949340574">"Odstr. používateľa"</string>
    <string name="user_new_user_name" msgid="7603010274765911161">"Otravné dieťa"</string>
    <string name="user_confirm_remove_title" msgid="3856148232937245711">"Odstrániť používateľa?"</string>
    <string name="user_confirm_remove_message" msgid="5284111415714437285">"Naozaj chcete odstrániť používateľa a všetky priradené údaje zo zariadenia?"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Zobraziť upozornenia"</string>
    <string name="help_label" msgid="1107174367904110532">"Pomocník"</string>
    <string name="cell_broadcast_settings" msgid="8415582011920085222">"Hromadné zasielanie správ v rámci bunky"</string>
    <string name="cell_broadcast_settings_summary" msgid="3301339398950905913">"Vyberte typy tiesňových upozornení, ktoré sa majú zobraziť."</string>
</resources>
