<?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">"Ano"</string>
    <string name="no" msgid="6731231425810196216">"Ne"</string>
    <string name="create" msgid="3578857613172647409">"Vytvořit"</string>
    <string name="allow" msgid="3349662621170855910">"Povolit"</string>
    <string name="deny" msgid="6947806159746484865">"Odmítnout"</string>
    <string name="dlg_close" msgid="7471087791340790015">"Zavřít"</string>
    <string name="dlg_switch" msgid="6243971420240639064">"Přepnout"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Neznámé"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="7201398282729229649">
      <item quantity="few">Ještě <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> kroky a bude z vás vývojář.</item>
      <item quantity="many">Ještě <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> kroku a bude z vás vývojář.</item>
      <item quantity="other">Ještě <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> kroků a bude z vás vývojář.</item>
      <item quantity="one">Ještě <xliff:g id="STEP_COUNT_0">%1$d</xliff:g> krok a bude z vás vývojář.</item>
    </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Voilà! Stal se z vás vývojář."</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Není potřeba, již jste vývojář."</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Bezdrátová připojení a sítě"</string>
    <string name="header_category_connections" msgid="6471513040815680662">"Připojení"</string>
    <string name="header_category_device" msgid="4544026001618307754">"Zařízení"</string>
    <string name="header_category_personal" msgid="3310195187905720823">"Osobní"</string>
    <string name="header_category_access" msgid="7580499097416970962">"Přístup"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Systém"</string>
    <string name="turn_on_radio" msgid="8706561489788373676">"Zapnout rádio"</string>
    <string name="turn_off_radio" msgid="1820294552893884115">"Vypnout rádio"</string>
    <string name="sms_over_ims_on" msgid="5085290395865632925">"Zapnout zprávy SMS prostřednictvím IMS"</string>
    <string name="sms_over_ims_off" msgid="8354792045992793959">"Vypnout zprávy SMS prostřednictvím IMS"</string>
    <string name="ims_reg_required_on" msgid="3885152087309614653">"Vyžaduje se zapnutí registrace IMS"</string>
    <string name="ims_reg_required_off" msgid="1720570343422743943">"Vyžaduje se vypnutí registrace IMS"</string>
    <string name="volte_provisioned_flag_on" msgid="6023503159480902956">"Zapnout příznak poskytnutí VoLTE"</string>
    <string name="volte_provisioned_flag_off" msgid="6168612015904744405">"Vypnout příznak poskytnutí VoLTE"</string>
    <string name="lte_ram_dump_on" msgid="8568568019520172177">"Zapnout výpis paměti lte ram"</string>
    <string name="lte_ram_dump_off" msgid="2514507918652378283">"Vypnout výpis paměti lte ram"</string>
    <string name="radioInfo_menu_viewADN" msgid="8743377494429930831">"Zobrazit adresář SIM karty"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Zobrazit povolená telefonní čísla"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Zobrazit čísla volání služeb"</string>
    <string name="radioInfo_menu_getPDP" msgid="560610293888406317">"Získat seznam PDP"</string>
    <string name="radioInfo_service_in" msgid="1915416319177520020">"V provozu"</string>
    <string name="radioInfo_service_out" msgid="5238736759641916278">"Nepokrytá oblast"</string>
    <string name="radioInfo_service_emergency" msgid="2485604591272668370">"Pouze tísňová volání"</string>
    <string name="radioInfo_service_off" msgid="1434084741785525415">"Rádio je vypnuto"</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ánění"</string>
    <string name="radioInfo_phone_offhook" msgid="4174402846862780998">"Probíhající hovor"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Odpojeno"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Připojování"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Připojeno"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Pozastaveno"</string>
    <string name="radioInfo_unknown" msgid="737385314432468266">"neznámý"</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">"Odpojit úložiště USB"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Odpojit kartu SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Smazat úložiště USB"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Smazat kartu SD"</string>
    <string name="small_font" msgid="2295331917424072635">"Malá"</string>
    <string name="medium_font" msgid="2068475425515133701">"Střední"</string>
    <string name="large_font" msgid="599055175160971446">"Velká"</string>
    <string name="font_size_save" msgid="3450855718056759095">"OK"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Úložiště USB"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"Karta SD"</string>
    <string name="battery_info_status_unknown" msgid="196130600938058547">"Neznámé"</string>
    <string name="battery_info_status_charging" msgid="1705179948350365604">"Nabíjí se"</string>
    <string name="battery_info_status_charging_ac" msgid="2909861890674399949">"Nabíjení z adaptéru"</string>
    <string name="battery_info_status_charging_usb" msgid="2207489369680923929">"Nabíjení přes USB"</string>
    <string name="battery_info_status_charging_wireless" msgid="3574032603735446573">"Bezdrátové nabíjení"</string>
    <string name="battery_info_status_discharging" msgid="310932812698268588">"Nenabíjí se"</string>
    <string name="battery_info_status_not_charging" msgid="2820070506621483576">"Nenabíjí se"</string>
    <string name="battery_info_status_full" msgid="2824614753861462808">"Nabitá"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"Viditelné pro všechna okolní zařízení Bluetooth (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Viditelné pro všechny okolní zařízení Bluetooth"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Neviditelné pro ostatní zařízení Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Viditelné pouze pro spárovaná zařízení"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Časový limit viditelnosti"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Uzamknout hlasové vytáčení"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Zabránit použití vytáčení Bluetooth při uzamčené obrazovce"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Zařízení Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Název zařízení"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Nastavení zařízení"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Nastavení profilu"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Název není nastaven, použit název účtu"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Vyhledat zařízení"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Přejmenovat toto zařízení"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Přejmenovat"</string>
    <string name="bluetooth_disconnect_title" msgid="6026705382020027966">"Odpojit?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="9148530542956217908">"Tímto způsobem ukončíte připojení k zařízení:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="603521233563983689">"Nemáte oprávnění měnit nastavení Bluetooth."</string>
    <string name="bluetooth_is_visible_message" msgid="6222396240776971862">"Při zapnutém připojení Bluetooth je zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> viditelné pro zařízení v okolí."</string>
    <string name="bluetooth_is_disconnect_question" msgid="5334933802445256306">"Odpojit zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Vysílání"</string>
    <string name="bluetooth_disable_profile_title" msgid="5916643979709342557">"Deaktivovat profil?"</string>
    <string name="bluetooth_disable_profile_message" msgid="2895844842011809904">"Toto nastavení vypne profil:&lt;br&gt;&lt;b&gt;<xliff:g id="PROFILE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Zařízení:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_unknown" msgid="644716244548801421"></string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Nepojmenované zařízení Bluetooth"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Hledání"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"V okolí nejsou žádná zařízení Bluetooth."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Požadavek na párování zařízení Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Požadavek na párování"</string>
    <string name="bluetooth_notif_message" msgid="5300852675110479862">"Klepnutím spárujete se zařízením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="5164787486105868895">"Zobrazit přijaté soubory"</string>
    <string name="device_picker" msgid="4978696506172252813">"Vybrat zařízení Bluetooth"</string>
    <string name="bluetooth_permission_request" msgid="1523129741266262748">"Požadavek na povolení zařízení Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1712443355224737143">"Nějaká aplikace žádá o zapnutí rozhraní Bluetooth v tomto zařízení."</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="786921566047356213">"Aplikace požaduje zviditelnění tabletu pro ostatní zařízení Bluetooth na <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="5510358858113713272">"Aplikace požaduje zviditelnění telefonu pro ostatní zařízení Bluetooth na <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8863617309580598607">"Aplikace chce tablet zviditelnit pro ostatní zařízení Bluetooth. Toto můžete později změnit v nastavení Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="6487606808683607975">"Aplikace chce telefon zviditelnit pro ostatní zařízení Bluetooth. Toto můžete později změnit v nastavení Bluetooth."</string>
    <string name="bluetooth_ask_start_broadcast" product="default" msgid="3535628155254187911">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnout vysílání Bluetooth za účelem komunikace s ostatními zařízeními v okolí. Svoji volbu můžete později změnit v nastavení rozhraní Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_start_broadcast" product="default" msgid="8810858601242763295">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnout Bluetooth a vysílání Bluetooth za účelem komunikace s ostatními zařízeními v okolí. Svoji volbu můžete později změnit v nastavení rozhraní Bluetooth."</string>
    <string name="bluetooth_broadcasting_explaination" product="default" msgid="4249322115655011799">"Když je tato funkce zapnutá, váš telefon může komunikovat s ostatními zařízeními v okolí.\n\nVysílání využívá nízkoenergetické signály Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="3346529092809011149">"Aplikace chce zapnout Bluetooth a na <xliff:g id="TIMEOUT">%1$d</xliff:g> s tablet zviditelnit pro ostatní zařízení."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="4724094889807196118">"Aplikace chce zapnout Bluetooth a na <xliff:g id="TIMEOUT">%1$d</xliff:g> s telefon zviditelnit pro ostatní zařízení."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="989613204829097159">"Aplikace chce zapnout Bluetooth a zviditelnit tablet pro ostatní zařízení. Později to můžete změnit v nastavení Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6671615712909139801">"Aplikace chce zapnout Bluetooth a zviditelnit telefon pro ostatní zařízení. Později to můžete změnit v nastavení Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Zapínání Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Vypínání rozhraní Bluetooth…"</string>
    <string name="bluetooth_auto_connect" msgid="40711424456733571">"Automatické připojení"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Požadavek na připojení zařízení Bluetooth"</string>
    <string name="bluetooth_connection_notif_message" msgid="3687933246423942977">"Klepnutím se připojíte k zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Chcete se připojit k zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Požadavek na přístup k telefonnímu seznamu"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="6555508756987053866">"Zařízení %1$s žádá o přístup k vašim kontaktům a historii hovorů. Povolit zařízení %2$s přístup?"</string>
    <string name="bluetooth_remember_choice" msgid="6919682671787049800">"Příště se neptat"</string>
    <string name="bluetooth_pb_remember_choice" msgid="3622898084442402071">"Příště se neptat"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Požadavek na přístup ke zprávám"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"Zařízení %1$s žádá o přístup k vašim zprávám. Povolit přístup zařízení %2$s?"</string>
    <string name="bluetooth_sap_request" msgid="2669762224045354417">"Žádost o přístup k SIM kartě"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="4414253873553608690">"Zařízení <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> žádá o přístup k SIM kartě. Po dobu přístupu zařízení k SIM kartě bude datové připojení ve vašem zařízení vypnuto. Chcete zařízení <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g> povolit přístup?"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Datum a čas"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Vybrat časové pásmo"</string>
    <string name="display_preview_label" msgid="1127597250917274792">"Náhled:"</string>
    <string name="display_font_size_label" msgid="8941851418397475389">"Velikost písma:"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Odeslat <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">"Spustit činnost <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Účet:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Proxy"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Vymazat"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Port proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Nepoužívat proxy server pro"</string>
    <string name="proxy_exclusionlist_hint" msgid="6084099226687226948">"example.com,mycomp.test.com,localhost"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Obnovit výchozí nastavení"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Hotovo"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Název hostitele proxy serveru"</string>
    <string name="proxy_hostname_hint" msgid="2076157057003936176">"proxy.example.com"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Upozornění"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="6865850167802455230">"Zadaný název hostitele není platný."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="678527645450894773">"Seznam vyloučení, který jste vytvořili, má nesprávný formát. Zadejte seznam názvů domén k vyloučení a jednotlivé názvy oddělte čárkami."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Je třeba vyplnit pole portu."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Pokud je pole hostitel prázdné, musí být prázdné i pole port."</string>
    <string name="proxy_error_invalid_port" msgid="5988270202074492710">"Zadaný port není platný."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Proxy server protokolu HTTP může používat prohlížeč, ale nesmí jej používat další aplikace."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"Adresa URL PAC: "</string>
    <string name="radio_info_signal_location_label" msgid="16475158265551708">"Místo:"</string>
    <string name="radio_info_neighboring_location_label" msgid="2385625674055934880">"Sousední identifikátor CID:"</string>
    <string name="radio_info_cellinfo_label" msgid="1300937728020622362">"CellInfo:"</string>
    <string name="radio_info_dcrtinfo_label" msgid="6802395441317448068">"Informace:"</string>
    <string name="radio_info_data_attempts_label" msgid="1731106244577323381">"Pokusy dat:"</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">"Přesměrované hovory:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3241667824729310546">"Počet obnovení protokolu PPP od spuštění:"</string>
    <string name="radio_info_gsm_disconnects_label" msgid="1683069665736339820">"Odpojení od sítě GSM:"</string>
    <string name="radio_info_current_network_label" msgid="3256402602440102610">"Aktuální síť:"</string>
    <string name="radio_info_data_successes_label" msgid="4417894113689054945">"Úspěšná data:"</string>
    <string name="radio_info_ppp_received_label" msgid="3345184342444878849">"Přijaté 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">"Síla signálu:"</string>
    <string name="radio_info_call_status_label" msgid="4896238900685510883">"Stav hovoru:"</string>
    <string name="radio_info_ppp_sent_label" msgid="5009102250704375687">"Odeslané informace PPP:"</string>
    <string name="radio_info_radio_resets_label" msgid="9211343458143291617">"Resety rádia:"</string>
    <string name="radio_info_message_waiting_label" msgid="6981842420058672207">"Čekající zprávy:"</string>
    <string name="radio_info_phone_number_label" msgid="7192944627907412169">"Telefonní číslo:"</string>
    <string name="radio_info_band_mode_label" msgid="441469694142042022">"Zvolit pásmo rádia"</string>
    <string name="radio_info_network_type_label" msgid="3706382548257257987">"Typ sítě:"</string>
    <string name="radio_info_set_perferred_label" msgid="9039200405863503267">"Upřednostňovaný typ sítě:"</string>
    <string name="radio_info_ping_ipaddr" msgid="498747917793263530">"Použít test Ping na IpAddr:"</string>
    <string name="radio_info_ping_hostname" msgid="3054888474808217853">"Provést test Ping hostitele (www.google.cz):"</string>
    <string name="radio_info_http_client_test" msgid="5733604021077701555">"Test klienta HTTP:"</string>
    <string name="ping_test_label" msgid="7255376471490860631">"Spustit test Ping"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Aktualizovat"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Aktualizovat"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="8292252930563286858">"Přepnout kontrolu DNS"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Informace a nastavení specifické pro výrobce OEM"</string>
    <string name="band_mode_title" msgid="954174198903776205">"Nastavit pásmo pro GSM a UMTS"</string>
    <string name="band_mode_loading" msgid="548764766363847336">"Načítání seznamu pásem..."</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Nastavit"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Neúspěšné"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Pásmo nastaveno."</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Změny se projeví při příštím připojení kabelu USB."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Povolit velkokapacitní úložiště USB"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Celková paměť (bajty):"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"Úložiště USB není připojeno."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Karta SD není k dispozici."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Dostupná paměť (bajty):"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"Úlož. USB užito jako velkokap."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"Karta SD je využívána jako velkokapacitní paměťové zařízení."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="5128923500235719226">"Úlož. USB lze bezp. odebrat."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="666233604712540408">"Nyní můžete kartu SD bezpečně odebrat."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"Úlož. USB odebráno za provozu."</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"Karta SD byla odstraněna za provozu."</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Obsazená paměť (bajty):"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Hledání médií v úložišti USB…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Vyhledávání mediálních souborů na kartě SD..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"Úlož. USB připoj. jen ke čtení"</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"Karta SD je připojena pouze pro čtení."</string>
    <string name="skip_label" msgid="47510779345218297">"Přeskočit"</string>
    <string name="next_label" msgid="4693520878012668114">"Další"</string>
    <string name="language_picker_title" msgid="5349877711342869319">"Jazyk"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Vybrat aktivitu"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Info o zařízení"</string>
    <string name="display_label" msgid="8074070940506840792">"Displej"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Informace o tabletu"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informace o telefonu"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Úložiště USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"Karta SD"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Nastavení proxy serveru"</string>
    <string name="cancel" msgid="6859253417269739139">"Zrušit"</string>
    <string name="okay" msgid="1997666393121016642">"OK"</string>
    <string name="forget" msgid="1400428660472591263">"Zapomenout"</string>
    <string name="save" msgid="879993180139353333">"Uložit"</string>
    <string name="done" msgid="6942539184162713160">"Hotovo"</string>
    <string name="settings_label" msgid="1626402585530130914">"Nastavení"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Nastavení"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Zástupce nastavení"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Režim Letadlo"</string>
    <string name="radio_controls_title" msgid="3447085191369779032">"Další"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Bezdrátová připojení a sítě"</string>
    <string name="radio_controls_summary" msgid="2837395036275123133">"Správa sítí Wi-Fi, rozhraní Bluetooth, režimu Letadlo, mobilních sítí a sítí VPN"</string>
    <string name="cellular_data_title" msgid="2525947635539415202">"Mobilní data"</string>
    <string name="calls_title" msgid="3544471959217176768">"Volání"</string>
    <string name="sms_messages_title" msgid="1778636286080572535">"Zprávy SMS"</string>
    <string name="cellular_data_summary" msgid="4575500999626276446">"Povolit využití dat přes mobilní síť"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Povolit data při roamingu"</string>
    <string name="roaming" msgid="3596055926335478572">"Datový roaming"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Používat datové služby při roamingu"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Používat datové služby při roamingu"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Připojení datových služeb bylo přerušeno, protože jste opustili domovskou síť a máte vypnutý datový roaming."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Zapnout"</string>
    <string name="roaming_warning" msgid="7625933694709170887">"Pokud povolíte datový roaming, mohou vám být účtovány vysoké poplatky."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Pokud aktivujete datový roaming, mohou vám být za roaming účtovány nemalé poplatky.\n\nToto nastavení ovlivní všechny uživatele tohoto tabletu."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Pokud aktivujete datový roaming, mohou vám být za roaming účtovány nemalé poplatky.\n\nToto nastavení ovlivní všechny uživatele tohoto telefonu."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Povolit datový roaming?"</string>
    <string name="networks" msgid="6333316876545927039">"Výběr operátora"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Vybrat síťového operátora"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Datum a čas"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Nastavit datum a čas"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Umožňuje nastavit datum, čas, časové pásmo a formát"</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Automatické datum a čas"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Používat čas ze sítě"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Používat čas ze sítě"</string>
    <string name="zone_auto" msgid="334783869352026648">"Automatické čas. pásmo"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Používat časové pásmo ze sítě"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Používat časové pásmo ze sítě"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"24hodinový formát"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Používat 24hodinový formát"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Čas"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Nastavit čas"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Časové pásmo"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Časové pásmo"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Datum"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Nastavit datum"</string>
    <string name="zone_list_menu_sort_alphabetically" msgid="5683377702671088588">"Seřadit abecedně"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="2720190443744884114">"Seřadit podle časového pásma"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Datum"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Čas"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Automaticky zamknout za"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po přechodu do spánku"</string>
    <string name="lock_immediately_summary_with_exception" msgid="9119632173886172690">"Okamžitě po režimu spánku, pokud odemknutí není udržováno pomocí agenta <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="5579064842797188409">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po přechodu do spánku, pokud odemknutí není udržováno funkcí <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Zobrazovat vlastníka na zamčené obrazovce"</string>
    <string name="owner_info_settings_title" msgid="5530285568897386122">"Zpráva na zamčené obrazovce"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Aktivovat widgety"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="1557090442377855233">"Zakázáno administrátorem"</string>
    <string name="owner_info_settings_summary" msgid="7472393443779227052">"Žádná"</string>
    <string name="owner_info_settings_status" msgid="120407527726476378">"<xliff:g id="COUNT_0">%1$d</xliff:g> / <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="7591869574491036360">"Např. Tomův Android."</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Info o uživateli"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Zobrazit informace o profilu na zamčené obrazovce"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Informace o profilu"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Účty"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Poloha"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Účty"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Zabezpečení"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Moje poloha, odemknutí obrazovky, zámek SIM, zámek úložiště pověření"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Nastavení funkce Moje poloha, odemknutí obrazovky a zamknutí úložiště pověření"</string>
    <string name="security_passwords_title" msgid="2930627259125138363">"Hesla"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2488725232406204350">"Otisk prstu"</string>
    <string name="fingerprint_manage_category_title" msgid="8293801041700001681">"Správa otisků prstů"</string>
    <string name="fingerprint_usage_category_title" msgid="8438526918999536619">"K čemu otisk používat"</string>
    <string name="fingerprint_add_title" msgid="1926752654454033904">"Přidat otisk prstu"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5078060939636911795">"zámek obrazovky"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="624961700033979880">
      <item quantity="few">Nastavení <xliff:g id="COUNT_1">%1$d</xliff:g> otisků prstu</item>
      <item quantity="many">Nastavení <xliff:g id="COUNT_1">%1$d</xliff:g> otisku prstu</item>
      <item quantity="other">Nastavení <xliff:g id="COUNT_1">%1$d</xliff:g> otisků prstu</item>
      <item quantity="one">Nastavení <xliff:g id="COUNT_0">%1$d</xliff:g> otisku prstu</item>
    </plurals>
    <string name="security_settings_fingerprint_enroll_onboard_title" msgid="4735546436672054254">"Nastavení otisku prstu"</string>
    <string name="security_settings_fingerprint_enroll_onboard_message" msgid="2655449737443418341">"Aby bylo možné pomocí otisku prstu odemykat obrazovku a potvrzovat nákupy, bude potřeba provést následující:"</string>
    <string name="security_settings_fingerprint_enroll_onboard_message_1" msgid="2799884038398627882">"Nastavte záložní metodu zámku obrazovky."</string>
    <string name="security_settings_fingerprint_enroll_onboard_message_2" msgid="4158160658182631304">"přidat otisk prstu."</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="3201556857492526098">"Odemknutí otiskem prstu"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="5061093614328964700">"Odemykejte telefon, autorizujte nákupy a přihlašujte se do aplikací pouhým klepnutím na senzor otisků prstů. Tyto věci bude možné provádět pomocí všech otisků prstů přidaných do telefonu. Při přidávání dalších lidí proto buďte opatrní."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_warning" msgid="7173290350577831813">"Poznámka: Otisk prstu může být méně bezpečný než silné gesto nebo PIN."</string>
    <string name="security_settings_fingerprint_enroll_introduction_risk_link_text" msgid="9129531466157620977">"Další informace"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="3199351118385606526">"Zrušit"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="7472492858148162530">"Pokračovat"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="5877265753699187149">"Najděte senzor"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="1959655161889313661">"Najděte senzor otisků prstů na zadní straně telefonu."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="2058830032070449160">"Ilustrace se zařízením a polohou senzoru otisků prstů"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7086763077909041106">"Jméno"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4150384963879569750">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="4114615413240707936">"Smazat"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="9192567284554495805">"Začínáme!"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="6294541599045187369">"Přiložte prst na senzor otisků. Až ucítíte vibraci, zvedněte jej."</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="3732060789409510229">"OK, nyní to zopakujte"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="8846866512704467036">"Přiložte na senzor otisků stejný prst a až ucítíte vibraci, zvedněte jej."</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="4798692662828257300">"Otisk byl přidán!"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="835496875787664316">"Kdykoli se zobrazí tato ikona, můžete se identifikovat nebo autorizovat nákup pomocí svého otisku prstu."</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="1195743489835505376">"Nastavit zámek obrazovky"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="4014607378328187567">"Hotovo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="1863561601428695160">"Jejda, to není senzor."</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="5053971232594165142">"Použijte senzor otisků prstů na zařízení."</string>
    <string name="fingerprint_enroll_button_add" msgid="6317978977419045463">"Přidat další"</string>
    <string name="fingerprint_enroll_button_next" msgid="6247009337616342759">"Další"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="2624905914239271751">"Kromě odemknutí telefonu můžete svůj otisk prstu použít také k autorizaci nákupů a přístupu aplikací. "<annotation id="url">"Další informace"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="4504501581228672208">"Možnost zámku obrazovky byla zakázána. Svůj otisk prstu můžete i nadále používat k autorizaci nákupů a přístupu k aplikacím. "<annotation id="url">"Další informace"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="1888772560642539718">"Zvedněte prst a poté na senzor klepněte znovu."</string>
    <string name="setup_fingerprint_enroll_finish_message" msgid="4132164775128798343">"Kdykoli se zobrazí tato ikona, můžete použít svůj otisk prstu."</string>
    <string name="setup_fingerprint_enroll_finish_secondary_message" msgid="3734962461534384882">"Chcete-li změnit nastavení, přejděte na Nastavení &gt; Zabezpečení &gt; Otisk prstu."</string>
    <string name="fingerprint_add_max" msgid="1020927549936895822">"Maximální počet otisků prstů, které lze přidat: <xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="confirm_fingerprint_icon_content_description" msgid="5255544532157079096">"Pokračujte přiložením prstu."</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Šifrování"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Šifrovat tablet"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Šifrování telefonu"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Šifrováno"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="503014594435731275">"Své účty, nastavení, stažené aplikace a jejich data, média a další soubory můžete zašifrovat. Pokud tablet zašifrujete a nastavili jste zámek obrazovky (bezpečnostní gesto, číselný kód PIN nebo heslo), bude třeba jej při každém zapnutí dešifrovat odemknutím obrazovky. Dešifrování lze provést pouze obnovením továrních dat, kterým vymažete všechna svá data.\n\nŠifrování trvá hodinu nebo i déle. Šifrování je třeba zahájit s plně nabitou baterií a tablet je třeba mít během procesu zapojený do zásuvky.Pokud šifrování přerušíte, přijdete o některá nebo všechna svá data."</string>
    <string name="crypt_keeper_desc" product="default" msgid="2579929266645543631">"Své účty, nastavení, stažené aplikace a jejich data, média a další soubory můžete zašifrovat. Pokud telefon zašifrujete a nastavili jste zámek obrazovky (bezpečnostní gesto, číselný kód PIN nebo heslo), bude třeba jej při každém zapnutí dešifrovat odemknutím obrazovky. Jediným dalším způsobem dešifrování je obnovení továrních nastavení, kterým vymažete všechna svá data.\n\nŠifrování trvá hodinu nebo i déle. Šifrování je potřeba zahájit s nabitou baterií a během šifrování je potřeba ponechat telefon připojený ke zdroji napájení. Pokud šifrování přerušíte, přijdete o některá nebo všechna svá data."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Šifrovat tablet"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Šifrovat telefon"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Nabijte baterii a zkuste to znovu."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Připojte nabíječku a zkuste to znovu."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Chybí heslo nebo kód PIN zámku obrazovky"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Před začátkem šifrování musíte nastavit kód PIN nebo heslo zámku obrazovky."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Zašifrovat?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="517662068757620756">"Zašifrování je nevratné, a pokud ho přerušíte, budou vaše data ztracena. Šifrování trvá hodinu i déle. Během této doby bude tablet několikrát restartován."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="287503113671320916">"Zašifrování je nevratné, a pokud ho přerušíte, budou vaše data ztracena. Šifrování trvá hodinu i více. Během této doby bude telefon několikrát restartován."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Šifrování"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Počkejte prosím, než bude tablet zašifrován. Dokončeno: <xliff:g id="PERCENT">^1</xliff:g> %"</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Počkejte prosím, než bude telefon zašifrován. Dokončeno: <xliff:g id="PERCENT">^1</xliff:g> %"</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="1655047311546745695">"Počkejte prosím, než bude tablet zašifrován. Zbývající čas: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="1862964662304683072">"Počkejte prosím, než bude telefon zašifrován. Zbývající čas: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="556504311511212648">"Chcete-li tablet odemknout, vypněte jej a poté jej znovu zapněte."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="1794353635603020327">"Chcete-li telefon odemknout, vypněte jej a poté jej znovu zapněte."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"Upozornění: Po <xliff:g id="COUNT">^1</xliff:g> dalších neúspěšných pokusech o odemknutí bude zařízení vymazáno!"</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Zadejte heslo"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Šifrování se nezdařilo"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="8219375738445017266">"Šifrování bylo přerušeno a nelze je dokončit. V důsledku toho již nebudou údaje v tabletu přístupné. \n\n Chcete-li tablet opět začít používat, je potřeba obnovit tovární nastavení. Po obnově budete moci v průběhu nastavení tabletu obnovit všechna data, která jsou zálohována v účtu Google."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3270131542549577953">"Šifrování bylo přerušeno a nelze je dokončit. V důsledku toho již nebudou údaje v telefonu přístupné. \n\nChcete-li telefon opět začít používat, je potřeba obnovit tovární nastavení. Po obnově budete moci v průběhu nastavení telefonu obnovit všechna data, která jsou zálohována v účtu Google."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="8759119849089795751">"Dešifrování se nezdařilo"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="840107296925798402">"Zadané heslo je správné, avšak data jsou poškozena.\n\nChcete-li tablet nadále používat, je nutné v něm obnovit tovární nastavení. Až budete tablet po obnově znovu nastavovat, bude možné obnovit veškerá data, která byla zálohována na váš účet Google."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="8843311420059663824">"Zadané heslo je správné, avšak data jsou poškozena.\n\nChcete-li telefon nadále používat, je nutné v něm obnovit tovární nastavení. Až budete telefon po obnově znovu nastavovat, bude možné obnovit veškerá data, která byla zálohována na váš účet Google."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Přepnout metodu zadávání"</string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Zámek obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Zámek obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Změna zámku obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Změnit nebo deaktivovat bezpečnostní gesto, kód PIN nebo heslo"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Vyberte způsob uzamknutí obrazovky"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Žádný"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Přejetí prstem"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Žádné zabezpečení"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Gesto"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Střední zabezpečení"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Střední až vysoké zabezpečení"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Heslo"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Vysoké zabezpečení"</string>
    <string name="current_screen_lock" msgid="4104091715420072219">"Aktuální zámek obrazovky"</string>
    <string name="unlock_disable_frp_warning_content" msgid="7070131836291098244">"Již nebudou fungovat funkce ochrany zařízení."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2120729867788851674">"Zakázáno správcem, zásadami šifrování nebo úložištěm pověření"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Žádná"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Přejetí prstem"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Gesto"</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_setup_wizard_fingerprint_details" msgid="7893457665921363009">"Po nastavení zámku obrazovky můžete v Nastavení &gt; Zabezpečení nastavit také otisk prstu."</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Vypnout zámek obrazovky"</string>
    <string name="unlock_disable_lock_pattern_summary" msgid="6801602880568869201">"Odebrat bezpečnostní gesto"</string>
    <string name="unlock_disable_lock_pin_summary" msgid="8856842745366993387">"Odebrat bezpečnostní kód PIN"</string>
    <string name="unlock_disable_lock_password_summary" msgid="192161194564577025">"Odebrat bezpečnostní heslo"</string>
    <string name="unlock_disable_lock_unknown_summary" msgid="8688498722601653961">"Odstranit tento zámek"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Změna bezpečnostního gesta"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Změna bezpečnostního kódu PIN"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Změnit bezpečnostní heslo"</string>
    <string name="lockpassword_password_too_short" msgid="7328975683669256660">"Heslo musí mít nejméně %d znaky"</string>
    <string name="lockpassword_pin_too_short" msgid="1677649103470518953">"Kód PIN musí obsahovat nejméně %d znaky"</string>
    <string name="lockpassword_press_continue" msgid="122706614386757182">"Po dokončení se dotkněte tlačítka Pokračovat"</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Pokračovat"</string>
    <string name="lockpassword_password_too_long" msgid="7016906583950201704">"Heslo musí mít méně než <xliff:g id="NUMBER">%d</xliff:g> znaků."</string>
    <string name="lockpassword_pin_too_long" msgid="6419879099090294052">"PIN musí mít méně než <xliff:g id="NUMBER">%d</xliff:g> číslic."</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="1079053457942945709">"Kód PIN musí obsahovat pouze číslice 0 až 9."</string>
    <string name="lockpassword_pin_recently_used" msgid="214840704635573454">"Administrátor zařízení neumožňuje používat nedávno užitý kód PIN."</string>
    <string name="lockpassword_illegal_character" msgid="8742901630116866738">"Heslo obsahuje neplatný znak."</string>
    <string name="lockpassword_password_requires_alpha" msgid="5203836082520634764">"Heslo musí obsahovat nejméně jedno písmeno."</string>
    <string name="lockpassword_password_requires_digit" msgid="3958033271435659825">"Heslo musí obsahovat alespoň jednu číslici."</string>
    <string name="lockpassword_password_requires_symbol" msgid="7226621405629726899">"Heslo musí obsahovat nejméně jeden symbol."</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="5677371623980347934">
      <item quantity="few">Heslo musí obsahovat alespoň %d písmena.</item>
      <item quantity="many">Heslo musí obsahovat alespoň %d písmena.</item>
      <item quantity="other">Heslo musí obsahovat alespoň %d písmen.</item>
      <item quantity="one">Heslo musí obsahovat alespoň jedno písmeno.</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="5396846200894553640">
      <item quantity="few">Heslo musí obsahovat alespoň %d malá písmena.</item>
      <item quantity="many">Heslo musí obsahovat alespoň %d malého písmena.</item>
      <item quantity="other">Heslo musí obsahovat alespoň %d malých písmen.</item>
      <item quantity="one">Heslo musí obsahovat alespoň jedno malé písmeno.</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="2483949715040341677">
      <item quantity="few">Heslo musí obsahovat alespoň %d velká písmena.</item>
      <item quantity="many">Heslo musí obsahovat alespoň %d velkého písmena.</item>
      <item quantity="other">Heslo musí obsahovat alespoň %d velkých písmen.</item>
      <item quantity="one">Heslo musí obsahovat alespoň jedno velké písmeno.</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="9156410893744210033">
      <item quantity="few">Heslo musí obsahovat alespoň %d číslice.</item>
      <item quantity="many">Heslo musí obsahovat alespoň %d číslice.</item>
      <item quantity="other">Heslo musí obsahovat alespoň %d číslic.</item>
      <item quantity="one">Heslo musí obsahovat alespoň jednu číslici.</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="5384442837439742233">
      <item quantity="few">Heslo musí obsahovat alespoň %d speciální symboly.</item>
      <item quantity="many">Heslo musí obsahovat alespoň %d speciálního symbolu.</item>
      <item quantity="other">Heslo musí obsahovat alespoň %d speciálních symbolů.</item>
      <item quantity="one">Heslo musí obsahovat alespoň jeden speciální symbol.</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="4175064976268466293">
      <item quantity="few">Heslo musí obsahovat alespoň %d znaky jiné než písmena.</item>
      <item quantity="many">Heslo musí obsahovat alespoň %d znaku jiného než písmeno.</item>
      <item quantity="other">Heslo musí obsahovat alespoň %d znaků jiných než písmena.</item>
      <item quantity="one">Heslo musí obsahovat alespoň jeden znak jiný než písmeno.</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="4687102591995446860">"Administrátor zařízení neumožňuje použít heslo, které jste použili nedávno."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="6830610582179569631">"Posloupnost rostoucích, klesajících nebo opakovaných číslic je zakázána."</string>
    <string name="lockpassword_ok_label" msgid="313822574062553672">"OK"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Zrušit"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Zrušit"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Další"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Nastavení je dokončeno."</string>
    <string name="device_admin_title" msgid="3562216873644263804">"Správa zařízení"</string>
    <string name="manage_device_admin" msgid="5059296715271077278">"Správci zařízení"</string>
    <string name="manage_device_admin_summary" msgid="7672709110988761075">"Zobrazit nebo deaktivovat správce zařízení"</string>
    <string name="manage_trust_agents" msgid="4629279457536987768">"Agenti důvěry"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Před použitím nejdříve nastavte zámek obrazovky"</string>
    <string name="manage_trust_agents_summary" msgid="6804319935640148441">"Zobrazit nebo deaktivovat agenty důvěry"</string>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Zapnout 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">"Umožňuje spravovat připojení, nastavit název zařízení a viditelnost"</string>
    <string name="bluetooth_pairing_request" msgid="6385750334766370310">"Požadavek na párování zařízení Bluetooth"</string>
    <string name="bluetooth_enter_pin_msg" msgid="4954085254142996877">"Zařízení"</string>
    <string name="bluetooth_pairing_key_msg" msgid="333005542843637754">"Párovací kód"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Zadejte párovací kód a poté stiskněte Return nebo Enter."</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"Kód PIN obsahuje písmena nebo symboly"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Obvykle 0000 nebo 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="7849359451584101077">"Je nutné zadat 16 číslic."</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Tento kód PIN bude možná nutné zadat i v dalším zařízení."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Tento přístupový klíč bude možná nutné zadat i v druhém zařízení."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Párování se zařízení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;Zkontrolujte, zda zařízení zobrazuje tento přístupový klíč:&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">"Ze zařízení:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Spárovat s tímto zařízením?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Párování se zařízení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>Zadejte:<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 poté stiskněte klávesu Return nebo Enter."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="1655930908614072491">"Udělit připojenému zařízení přístup ke kontaktům a historii volání"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_connecting_error_message" msgid="1397388344342081090">"K zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> se nelze připojit."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Vyhledat zařízení"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Obnovit"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Hledání…"</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Nastavení zařízení"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Spárované zařízení"</string>
    <string name="bluetooth_preference_paired_dialog_name_label" msgid="8111146086595617285">"Název"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Připojení k internetu"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Klávesnice"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Kontakty a historie volání"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Párovat s tímto zařízením?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Sdílet telefonní seznam?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> žádá o přístup k vašim kontaktům a historii volání."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="8451248193517851958">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> žádá o spárování s Bluetooth. Po spojení bude mít přístup ke kontaktům a historii volání."</string>
    <string name="bluetooth_preference_paired_devices" msgid="1970524193086791964">"Spárovaná zařízení"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Dostupná zařízení"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"Nejsou dostupná žádná zařízení"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Připojit"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Odpojit"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Párovat a připojit"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Zrušit párování"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Odpojit a zrušit párování"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Možnosti"</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Rozšířené nastavení"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Rozšířené nastavení Bluetooth"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Když je zapnuté připojení Bluetooth, zařízení může komunikovat s ostatními zařízeními Bluetooth v okolí."</string>
    <string name="ble_scan_notify_text" msgid="1295915006005700650">"Za účelem zvýšení přesnosti určování polohy mohou systémové aplikace a služby neustále vyhledávat zařízení Bluetooth. Toto chování můžete změnit v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastavení vyhledávání<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Připojit k síti…"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojeno od zvuku médií."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojeno od zvuku sady handsfree."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojeno od vstupního zařízení."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Internetové připojení pomocí zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojeno."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="1262792320446274407">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojeno od sdíleného internetového připojení tohoto tabletu."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="5700332050175684571">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojeno od sdíleného internetového připojení telefonu."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Spárované zařízení Bluetooth"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Připojit"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Umožňuje připojení zařízení s rozhraním Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Použít pro"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Přejmenovat"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Povolit přích. přenosy souborů"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="4602294638909590612">"Připojeno k zařízení za účelem přístupu k internetu"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1561383706411975199">"Místní internetové připojení je sdíleno se zařízením"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Nastavení doku"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Použít zvuk doku"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Jako telefon pro hlasitý poslech"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Pro hudbu a média"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Zapamatovat nastavení"</string>
    <string name="wifi_assistant_title" msgid="2553267316621598101">"Google Wi‑Fi Assistant"</string>
    <string name="wifi_display_settings_title" msgid="8740852850033480136">"Odeslat"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Povolit bezdrátové zobrazení"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"V okolí nebyla nalezena žádná zařízení."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Připojování"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Připojené"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"Používá se"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Není k dispozici"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Nastavení displeje"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Možnosti bezdrátového displeje"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Odstranit"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Hotovo"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Název"</string>
    <string name="wifi_band_24ghz" msgid="852929254171856911">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="6433822023268515117">"5 GHz"</string>
    <string name="link_speed" msgid="8896664974117585555">"%1$d Mb/s"</string>
    <string name="wifi_alert_lockdown_by_device_owner" msgid="8459738223049002970">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g>, která spravuje vaše zařízení, nepovoluje úpravy ani smazání této sítě Wi-Fi. O další informace požádejte svého administrátora."</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Povolit výměnu dat, pokud se tablet dotkne jiného zařízení"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Povolit výměnu dat, pokud se telefon dotkne jiného zařízení"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Přenos obsahu aplikace prostřednictvím NFC je připraven"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Vypnuto"</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Není k dispozici, protože je vypnuta funkce NFC"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="6981652347448777459">"Pokud je funkce zapnuta, můžete přenášet obsah aplikace do jiného zařízení s funkcí NFC tím, že podržíte zařízení blízko sebe. Můžete například přenášet stránky prohlížeče, videa YouTube, kontakty a další.\n\nPřiložte zařízení k sobě (zpravidla zadní stranou) a dotkněte se obrazovky. Aplikace určí, jaký obsah se bude přenášet."</string>
    <string name="nsd_quick_toggle_title" msgid="3125572815278848258">"Zjistitelnost po síti"</string>
    <string name="nsd_quick_toggle_summary" msgid="155692215972781276">"Povolit aplikacím v jiných zařízeních vyhledávat aplikace v tomto zařízení"</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Zapnout Wi-Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Nastavení Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi-Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Umožňuje nastavit a spravovat přístupové body bezdrátové sítě"</string>
    <string name="wifi_setup_wizard_title" msgid="7873622558088429710">"Vyberte síť Wi-Fi"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Vyberte síť Wi-Fi"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Zapínání Wi‑Fi…"</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Vypínání Wi‑Fi…"</string>
    <string name="wifi_error" msgid="3207971103917128179">"Chyba"</string>
    <string name="wifi_sap_no_channel_error" msgid="3108445199311817111">"V této zemi není pásmo 5 GHz k dispozici"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"Při režimu Letadlo"</string>
    <string name="wifi_notify_open_networks" msgid="3755768188029653293">"Oznamování sítě"</string>
    <string name="wifi_notify_open_networks_summary" msgid="3716818008370391253">"Upozornit, když bude dostupná veřejná síť"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Ignorovat slabá připojení"</string>
    <string name="wifi_poor_network_detection_summary" msgid="2784135142239546291">"Nepoužívat síť Wi-Fi, pokud nemá dostatečně kvalitní internetové připojení"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4674423884870027498">"Použít jen sítě s dobrým připojením k internetu"</string>
    <string name="wifi_automatically_connect_title" msgid="7950640291510621742">"Automaticky používat otevřené sítě Wi-Fi"</string>
    <string name="wifi_automatically_connect_summary" msgid="6722194413023965902">"Nechat asistenta Wi‑Fi automaticky se připojit ke kvalitním otevřeným sítím"</string>
    <string name="wifi_select_assistant_dialog_title" msgid="4014645210955009439">"Zvolit asistenta"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Instalace certifikátů"</string>
    <string name="wifi_scan_notify_text" msgid="5593805423071186757">"Za účelem zlepšení přesnosti určování polohy mohou systémové aplikace a služby neustále vyhledávat sítě Wi-Fi. Toto chování můžete změnit v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastavení vyhledávání<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="7104867814641144485">"Tuto zprávu příště nezobrazovat"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Wi-Fi aktivní i v režimu spánku"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"Wi-Fi aktivní i v režimu spánku"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Při změně nastavení se vyskytl problém"</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Zlepšit výkonnost"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimalizace Wi-Fi"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Minimalizovat využívání baterie při zapnuté síti Wi-Fi"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Omezit využití baterie sítí Wi‑Fi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="1410499115509796174">"Pokud síť Wi‑Fi ztratí přístup k internetu, přepnout na mobilní data"</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Přidat síť"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Sítě Wi-Fi"</string>
    <string name="wifi_menu_wps_pbc" msgid="2668564692207863017">"Tlačítko WPS"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Další možnosti"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"Zadání kódu WPS PIN"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Wi‑Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Vyhledávání"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Rozšířené nastavení"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Připojit k síti"</string>
    <string name="wifi_menu_remember" msgid="8814185749388713796">"Zapamatovat síť"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Odstranit záznam sítě"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Upravit síť"</string>
    <string name="wifi_menu_write_to_nfc" msgid="7692881642188240324">"Zápis na štítek NFC"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Chcete-li zobrazit dostupné sítě, zapněte Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Vyhledávání sítí Wi-Fi…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="7322372065475939129">"Nemáte oprávnění ke změně sítě Wi-Fi."</string>
    <string name="wifi_other_network" msgid="1484433183857764750">"Přidat další síť"</string>
    <string name="wifi_more" msgid="3195296805089107950">"Další"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Automat. nastavení (WPS)"</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Rozšířené možnosti"</string>
    <string name="wifi_wps_setup_title" msgid="8207552222481570175">"Chráněné nastavení Wi-Fi"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"Spouštění WPS…"</string>
    <string name="wifi_wps_onstart_pbc" msgid="817003360936932340">"Stiskněte na směrovači tlačítko Chráněné nastavení Wi-Fi. Může být označeno textem „WPS“ nebo tímto symbolem:"</string>
    <string name="wifi_wps_onstart_pin" msgid="223344506445335358">"Zadejte ve svém směrovači sítě Wi-Fi kód PIN <xliff:g id="NUMBER">%1$s</xliff:g>. Proces nastavení může trvat až dvě minuty."</string>
    <string name="wifi_wps_complete" msgid="2388138550456729134">"Spuštění WPS se podařilo. Probíhá připojení k síti..."</string>
    <string name="wifi_wps_connected" msgid="7153432445748931183">"Připojeno k síti Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_wps_in_progress" msgid="3372311348221357944">"Nastavování WPS probíhá a dokončení procesu může trvat až dvě minuty."</string>
    <string name="wifi_wps_failed_generic" msgid="5668775022238832527">"Spuštění WPS se nezdařilo. Zkuste to znovu za několik minut."</string>
    <string name="wifi_wps_failed_wep" msgid="2702820087105284461">"Nastavení zabezpečení bezdrátového směrovače (WEP) není podporováno"</string>
    <string name="wifi_wps_failed_tkip" msgid="4282401586860713349">"Nastavení zabezpečení bezdrátového směrovače (TKIP) není podporováno"</string>
    <string name="wifi_wps_failed_auth" msgid="1174614355181181958">"Chyba ověření. Zkuste to prosím znovu."</string>
    <string name="wifi_wps_failed_overlap" msgid="5159533685596844778">"Byla zjištěna další relace WPS. Zkuste prosím to znovu za několik minut."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Název sítě"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Zadejte SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Zabezpečení"</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Síla signálu"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Stav"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Rychlost připojení"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Frekvence"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"IP adresa"</string>
    <string name="passpoint_label" msgid="6381371313076009926">"Uloženo pomocí"</string>
    <string name="passpoint_content" msgid="8447207162397870483">"<xliff:g id="NAME">%1$s</xliff:g> – identifikační údaje"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"Metoda EAP"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Ověření Phase 2"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"Certifikát CA"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Certifikát uživatele"</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">"Zobrazovat heslo"</string>
    <string name="wifi_ap_band_config" msgid="1611826705989117930">"Vybrat pásmo přístupového bodu"</string>
    <string name="wifi_ap_choose_2G" msgid="8724267386885036210">"Pásmo 2,4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8137061170937978040">"Pásmo 5 GHz"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"Nastavení IP adresy"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(nezměněno)"</string>
    <string name="wifi_unspecified" msgid="5431501214192991253">"(neurčeno)"</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WPS je k dispozici"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (WPS je k dispozici)"</string>
    <string name="wifi_wps_nfc_enter_password" msgid="2288214226916117159">"Zadejte heslo sítě"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnout vyhledávání sítí (kvůli lepšímu určení polohy i kvůli jiným účelům) a hledat sítě i v případě, že je vypnut modul Wi-Fi.\n\nChcete tuto možnost povolit všem aplikacím, které chtějí vyhledávat sítě?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="5538901671131941043">"Chcete-li toto nastavení vypnout, přejděte do rozbalovací nabídky Rozšířené."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Povolit"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Zamítnout"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Chcete se přihlásit, abyste se mohli připojit?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> vyžaduje, abyste se před připojením k síti přihlásili na webu."</string>
    <string name="wifi_hotspot_connect" msgid="5065506390164939225">"PŘIPOJIT"</string>
    <string name="no_internet_access_text" msgid="7133561752896706392">"Tato síť nemá přístup k internetu. Chcete zůstat připojeni?"</string>
    <string name="no_internet_access_remember" msgid="4697314331614625075">"U této sítě se již nedotazovat"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Připojit"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Připojení k síti se nezdařilo."</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Odstranit"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Odstranění záznamu sítě se nezdařilo."</string>
    <string name="wifi_save" msgid="3331121567988522826">"Uložit"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Uložení sítě se nezdařilo."</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Zrušit"</string>
    <string name="wifi_skip_anyway" msgid="6965361454438011190">"Přesto přeskočit"</string>
    <string name="wifi_dont_skip" msgid="1677493161164629163">"Nepřeskakovat"</string>
    <string name="wifi_skipped_message" product="tablet" msgid="6761689889733331124">"UPOZORNĚNÍ: Pokud přeskočíte nastavení Wi-Fi, tablet ke stažení počátečních souborů a aktualizací použije pouze mobilní datové připojení. Chcete-li zabránit možným poplatkům za přenos dat, připojte se k síti Wi‑Fi."</string>
    <string name="wifi_skipped_message" product="device" msgid="1385490367826852775">"UPOZORNĚNÍ: Pokud přeskočíte nastavení Wi-Fi, zařízení ke stažení počátečních souborů a aktualizací použije pouze mobilní datové připojení. Chcete-li zabránit možným poplatkům za přenos dat, připojte se k síti Wi‑Fi."</string>
    <string name="wifi_skipped_message" product="default" msgid="6084295135297772350">"UPOZORNĚNÍ: Pokud přeskočíte nastavení Wi-Fi, telefon ke stažení počátečních souborů a aktualizací použije pouze mobilní datové připojení. Chcete-li zabránit možným poplatkům za přenos dat, připojte se k síti Wi‑Fi."</string>
    <string name="wifi_and_mobile_skipped_message" product="tablet" msgid="6324917391996718760">"Pokud připojení Wi‑Fi přeskočíte:\n\n"<li>"tablet nebude připojen k internetu,"</li>\n\n<li>"aktualizace softwaru obdržíte až po připojení k internetu,"</li>\n\n<li>"funkce ochrany zařízení zatím nebudete moci aktivovat."</li></string>
    <string name="wifi_and_mobile_skipped_message" product="device" msgid="1110629752293998468">"Pokud připojení Wi‑Fi přeskočíte:\n\n"<li>"zařízení nebude připojeno k internetu,"</li>\n\n<li>"aktualizace softwaru obdržíte až po připojení k internetu,"</li>\n\n<li>"funkce ochrany zařízení zatím nebudete moci aktivovat."</li></string>
    <string name="wifi_and_mobile_skipped_message" product="default" msgid="8271524692702309267">"Pokud připojení Wi‑Fi přeskočíte:\n\n"<li>"telefon nebude připojen k internetu,"</li>\n\n<li>"aktualizace softwaru obdržíte až po připojení k internetu,"</li>\n\n<li>"funkce ochrany zařízení zatím nebudete moci aktivovat."</li></string>
    <string name="wifi_connect_failed_message" product="tablet" msgid="4474691090681670156">"Tabletu se nepodařilo připojit k této síti Wi-Fi."</string>
    <string name="wifi_connect_failed_message" product="device" msgid="8870885845666880869">"Zařízení se k této síti Wi-Fi nemohlo připojit."</string>
    <string name="wifi_connect_failed_message" product="default" msgid="2185803140161396572">"Telefonu se nepodařilo připojit k této síti Wi-Fi."</string>
    <string name="wifi_saved_access_points_titlebar" msgid="2996149477240134064">"Uložené sítě"</string>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Rozšířené nastavení"</string>
    <string name="wifi_setting_frequency_band_title" msgid="3655327399028584656">"Frekvenční pásmo Wi-Fi"</string>
    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Uveďte provozní frekvenční rozsah"</string>
    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Při nastavení frekvenčního pásma došlo k problému."</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Adresa MAC"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP adresa"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Uložené sítě"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"Nastavení IP adresy"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Uložit"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Zrušit"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Zadejte platnou IP adresu."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Zadejte prosím platnou adresu brány."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Zadejte prosím platnou adresu DNS."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Zadejte prosím délku síťové předpony 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élka síťové předpony"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Wi‑Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Informace o zařízení"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Pamatovat si toto připojení"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Vyhledat zařízení"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Hledání…"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Přejmenovat zařízení"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Partnerská zařízení"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Uložené skupiny"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8491862096448192157">"Nelze připojit."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Zařízení se nepodařilo přejmenovat."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Odpojit?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Pokud se odpojíte, vaše spojení se zařízením <xliff:g id="PEER_NAME">%1$s</xliff:g> bude přerušeno."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Pokud se odpojíte, bude spojení se zařízením <xliff:g id="PEER_NAME">%1$s</xliff:g> a s <xliff:g id="PEER_COUNT">%2$s</xliff:g> dalšími zařízeními přerušeno."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Zrušit pozvánku?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Chcete zrušit pozvánku ke spojení s klientem <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Odstranit tuto skupinu?"</string>
    <string name="wifi_tether_checkbox_text" msgid="1847167643625779136">"Přenosný hotspot Wi-Fi"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"Wi‑Fi hotspot"</string>
    <string name="wifi_hotspot_checkbox_text_summary" msgid="3800646230853724318">"Poskytovat připojení k síti Wi-Fi pomocí mobilního připojení"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Zapínání hotspotu…"</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Vypínání hotspotu…"</string>
    <string name="wifi_tether_enabled_subtext" msgid="8948641212931906143">"Přenosný hotspot <xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktivní"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Chyba přenosného hotspotu Wi-Fi"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Nastavit hotspot sítě Wi-Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Nastavení Wi‑Fi hotspotu"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5618031116920832182">"Přenosný hotspot Wi-Fi AndroidAP WPA2 PSK"</string>
    <string name="wifi_tether_configure_subtext" msgid="7957547035983257748">"Přenosný hotspot 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="wifi_calling_settings_title" msgid="4102921303993404577">"Volání přes Wi-Fi"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Předvolby volání"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="8149690312199253909">"Režim volání přes Wi-Fi"</string>
  <string-array name="wifi_calling_mode_choices">
    <item msgid="2124257075906188844">"Preferována síť W-Fi"</item>
    <item msgid="5267397515594230396">"Preferována mobilní síť"</item>
  </string-array>
  <string-array name="wifi_calling_mode_values">
    <item msgid="4799585830102342375">"2"</item>
    <item msgid="1171822231056612021">"1"</item>
  </string-array>
    <string name="wifi_calling_off_explanation" msgid="2597566001655908391">"Je-li zapnuto volání přes Wi-Fi, telefon může hovory v závislosti na zadaných nastaveních a na tom, který signál je silnější, směrovat přes sítě Wi-Fi nebo přes sítě operátora. Než tuto funkci zapnete, zeptejte se operátora na možné poplatky a další podrobnosti."</string>
    <string name="home_settings" msgid="212375129455718176">"Plocha"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Obrazovka"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Zvuk"</string>
    <string name="ringtone_summary" msgid="2630023412632683493"></string>
    <string name="all_volume_title" msgid="4296957391257836961">"Hlasitost"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Hudební efekty"</string>
    <string name="ring_volume_title" msgid="7938706566797464165">"Hlasitost vyzvánění"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibrovat v tichém režimu"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Výchozí zvuk oznámení"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Vyzváněcí tón"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Oznámení"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Použije hlasitost příchozích hovorů také pro oznámení"</string>
    <string name="home_work_profile_not_supported" msgid="7457951997970419085">"Nepodporuje pracovní profily"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Výchozí zvuk oznámení"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Média"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Umožňuje nastavit hlasitost hudby a videí"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Budík"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Nastavení zvuku pro připojený dok"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Tóny při dotyku číselníku"</string>
    <string name="sound_effects_enable_title" msgid="1171590821131077296">"Zvuky při dotyku"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Zvuk uzamčení obrazovky"</string>
    <string name="haptic_feedback_enable_title" msgid="2438293710530828760">"Při dotyku vibrovat"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Potlačení hluku"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Hudba, video, hry a další média"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Vyzvánění a oznámení"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Oznámení"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Budíky"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Vypnout zvuk vyzvánění a oznámení"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Vypnout zvuk hudby a jiných médií"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Vypnout zvuk oznámení"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Vypnout zvuk budíků"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Dokovací stanice"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Nastavení doku"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Zvuk"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Nastavení připojeného stolního doku"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Nastavení připojeného doku do auta"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tablet není vložen do doku"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefon není vložen do doku"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Nastavení připojeného doku"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Dok nebyl nalezen"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Chcete-li nastavit zvuk doku, musíte tablet vložit do doku."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Chcete-li nastavit zvuk doku, musíte telefon vložit do doku."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Zvuk při vložení do doku"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Při vložení nebo vyjmutí tabletu z doku přehrát zvuk"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Přehrát zvuk při vkládání nebo vyjímání telefonu z doku"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="4308252722466813560">"Při vložení nebo vyjmutí tabletu z doku nepřehrávat zvuk"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="2034927992716667672">"Nepřehrávat zvuk při vkládání nebo vyjímání telefonu z doku"</string>
    <string name="account_settings" msgid="6403589284618783461">"Účty"</string>
    <string name="category_personal" msgid="1299663247844969448">"Osobní"</string>
    <string name="category_work" msgid="8699184680584175622">"Pracovní"</string>
    <string name="accessibility_category_work" msgid="4339262969083355720">"Účty s pracovním profilem – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="1263518850905945594">"Účty s osobním profilem"</string>
    <string name="accessibility_work_account_title" msgid="1231830766637939527">"Pracovní účet – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="2169071663029067826">"Osobní účet – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="1910951467596035063">"Vyhledávání"</string>
    <string name="search_settings_summary" msgid="9205656546570654169">"Správa nastavení a historie vyhledávání"</string>
    <string name="display_settings" msgid="7965901687241669598">"Obrazovka"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Autom. otočení obrazovky"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Při otáčení tabletu automaticky přepínat orientaci"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Při otáčení telefonu automaticky přepínat orientaci"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Při otáčení tabletu automaticky přepínat orientaci"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Při otáčení telefonu automaticky přepínat orientaci"</string>
    <string name="brightness" msgid="8480105032417444275">"Úroveň jasu"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Jas"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Nastavení jasu displeje"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Adaptivní jas"</string>
    <string name="auto_brightness_summary" msgid="1799041158760605375">"Optimalizovat úroveň jasu podle okolního světla"</string>
    <string name="night_mode_title" msgid="6928425617491943384">"Motiv"</string>
    <string name="night_mode_summary" msgid="9196605054622017193">"%s"</string>
    <string name="night_mode_no" msgid="7682792841791457238">"Světlý"</string>
    <string name="night_mode_yes" msgid="4847655033618591567">"Tmavý"</string>
    <string name="night_mode_auto" msgid="7508348175804304327">"Automatický"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Režim spánku"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"Vypnutí obrazovky"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Doba nečinnosti: <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g>"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Tapeta"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Vybrat tapetu"</string>
    <string name="screensaver_settings_title" msgid="3349790120327233241">"Spořič obrazovky"</string>
    <string name="screensaver_settings_summary_either_long" msgid="2458481525925378465">"Při vložení do doku nebo při nabíjení v režimu spánku"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"V obou případech"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Při nabíjení"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Při vložení do doku"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Vyp."</string>
    <string name="screensaver_settings_disabled_prompt" msgid="3857507943322777651">"Chcete-li nastavit, co se má stát, když se telefon ocitne v doku nebo v režimu spánku, zapněte spořič obrazovky."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8352267826043957746">"Kdy spořič spustit"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Spustit"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Nastavení"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Automatický jas"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Probudit zvednutím zařízení"</string>
    <string name="doze_title" msgid="2259176504273878294">"Ambientní displej"</string>
    <string name="doze_summary" msgid="7128970177894383698">"Odemknout obrazovku, když zvednete zařízení nebo vám přijde upozornění"</string>
    <string name="title_font_size" msgid="4405544325522105222">"Velikost písma"</string>
    <string name="dialog_title_font_size" msgid="2231507851258955038">"Velikost písma"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Nastavení zámku SIM karty"</string>
    <string name="sim_lock_settings_category" msgid="5136244267576697004">"Nastavit zámek SIM karty"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Zámek SIM karty"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Zamykat SIM kartu"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"K použití tabletu je vyžadován kód PIN"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"K použití telefonu je vyžadován PIN"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"K použití tabletu je vyžadován kód PIN"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"K použití telefonu je vyžadován PIN"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Změnit PIN SIM karty"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"Kód PIN SIM karty"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Zamykat SIM kartu"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Odemknout SIM kartu"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Starý PIN SIM karty"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Nový PIN SIM karty"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Potvrďte nový kód PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"Kód PIN SIM karty"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Nesprávný kód PIN"</string>
    <string name="sim_pins_dont_match" msgid="1695021563878890574">"Kódy PIN nejsou shodné"</string>
    <string name="sim_change_failed" msgid="3602072380172511475">"Kód PIN nelze změnit.\nMožná jste zadali nesprávný kód PIN."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"PIN SIM karty byl úspěšně změněn."</string>
    <string name="sim_lock_failed" msgid="2489611099235575984">"Stav zámku SIM karty nelze změnit.\nZřejmě jste zadali nesprávný kód PIN."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"OK"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Zrušit"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"Bylo nalezeno několik SIM karet"</string>
    <string name="sim_multi_sims_summary" msgid="7018740080801483990">"Zvolte SIM kartu preferovanou pro mobilní datové přenosy."</string>
    <string name="sim_change_data_title" msgid="294357201685244532">"Změnit SIM kartu pro data?"</string>
    <string name="sim_change_data_message" msgid="1313940695939674633">"Chcete pro mobilní data namísto SIM karty <xliff:g id="OLD_SIM">%2$s</xliff:g> použít SIM kartu <xliff:g id="NEW_SIM">%1$s</xliff:g>?"</string>
    <string name="sim_preferred_title" msgid="5567909634636045268">"Změnit preferovanou SIM kartu?"</string>
    <string name="sim_preferred_message" msgid="301251431163650167">"<xliff:g id="NEW_SIM">%1$s</xliff:g> je jediná SIM karta v zařízení. Chcete tuto SIM kartu použít k mobilnímu datovému připojení, volání a odesílání zpráv SMS?"</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"Zadali jste nesprávný kód PIN SIM karty. Nyní musíte za účelem odemknutí zařízení kontaktovat svého operátora."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="1582398808893048097">
      <item quantity="few">Zadali jste nesprávný kód PIN SIM karty. Máte ještě <xliff:g id="NUMBER_1">%d</xliff:g> pokusy.</item>
      <item quantity="many">Zadali jste nesprávný kód PIN SIM karty. Máte ještě <xliff:g id="NUMBER_1">%d</xliff:g> pokusu.</item>
      <item quantity="other">Zadali jste nesprávný kód PIN SIM karty. Máte ještě <xliff:g id="NUMBER_1">%d</xliff:g> pokusů.</item>
      <item quantity="one">Zadali jste nesprávný PIN SIM karty. Zbývá <xliff:g id="NUMBER_0">%d</xliff:g> pokus, poté bude muset zařízení odemknout operátor.</item>
    </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Operace pomocí kódu PIN SIM karty se nezdařila!"</string>
    <string name="device_info_settings" product="tablet" msgid="1119755927536987178">"Stav tabletu"</string>
    <string name="device_info_settings" product="default" msgid="475872867864762157">"Stav telefonu"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Aktualizace systému"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Verze systému Android"</string>
    <string name="model_number" msgid="3765737700545384794">"Označení modelu"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"ID zařízení"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Verze základního pásma"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Verze jádra"</string>
    <string name="build_number" msgid="3075795840572241758">"Číslo sestavení"</string>
    <string name="selinux_status" msgid="6212165375172061672">"Stav zabezpečení SELinux"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Nedostupný"</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 baterie, sítě a další údaje"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Telefonní číslo, signál atd."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Úložiště"</string>
    <string name="storage_usb_settings" msgid="642612065405691122">"Úložiště a USB"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Nastavení úložiště"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Odpojení úložiště USB a zobrazení dostupného úložiště"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Umožňuje odpojit kartu SD a zobrazit dostupnou paměť"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5123197324870153205">"Moje telefonní čí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">"Verze PRL"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_network_type" msgid="952552009117455166">"Typ mobilní sítě"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Informace operátora"</string>
    <string name="status_data_state" msgid="4578972321533789767">"Stav mobilní sítě"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Stav služby"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Síla signálu"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Roaming"</string>
    <string name="status_operator" msgid="2274875196954742087">"Síť"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"Adresa MAC sítě Wi-Fi"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Adresa Bluetooth"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Sériové číslo"</string>
    <string name="status_unavailable" msgid="7862009036663793314">"Není k dispozici"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Doba provozu"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Doba provozu"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Interní úložiště"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"Úložiště USB"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"Karta SD"</string>
    <string name="memory_available" msgid="5052397223077021181">"K dispozici"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"K dispozici (pouze pro čtení)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Celková paměť"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Výpočet…"</string>
    <string name="memory_apps_usage" msgid="5128673488173839077">"Aplikace a data aplikací"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Média"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Stahování"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Fotografie, videa"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Zvuk (hudba, podcasty atd.)"</string>
    <string name="memory_media_misc_usage" msgid="6094866738586451683">"Jiné soubory"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Data uložená v mezipaměti"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Odpojit sdílené úložiště"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Odpojit kartu SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Odpojit interní úložiště USB"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"K bezpečnému odebrání karty SD je potřeba kartu nejprve odpojit"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Vložte úložiště USB"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Vložte kartu SD, kterou chcete připojit."</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Připojit úložiště USB"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Připojit 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">"Smazat úložiště USB"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Smazat kartu SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Smaže všechna data v interním úložišti USB, například hudbu a fotografie"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Smaže všechna data na kartě SD, například hudbu nebo fotografie"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Vymazat data uložená v mezipaměti?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Tímto vymažete z mezipaměti data všech aplikací."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"Funkce MTP nebo PTP je aktivní"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Odpojit úložiště USB?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Odpojit kartu SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Pokud úložiště USB odpojíte, některé používané aplikace přestanou fungovat. Tyto aplikace pravděpodobně nebudou k dispozici, dokud úložiště USB znovu nepřipojíte."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Pokud odpojíte kartu SD, dojde k zastavení některých používaných aplikací. Tyto aplikace pravděpodobně nebudou k dispozici až do opětovného připojení karty SD."</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="9191518889746166147">"Úložiště USB nelze odpojit. Zkuste to znovu později."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3500976899159848422">"Kartu SD nelze odpojit. Zkuste to znovu později."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"Úložiště USB bude odpojeno."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"Karta SD bude odpojena."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Odpojování"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Probíhá odpojování"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"V úložišti je málo místa"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Některé systémové funkce, jako například synchronizace, nemusejí fungovat správně. Zkuste uvolnit místo smazáním nebo uvolněním položek, jako jsou aplikace nebo multimediální obsah."</string>
    <string name="storage_menu_rename" msgid="7141058657592615390">"Přejmenovat"</string>
    <string name="storage_menu_mount" msgid="1014683672493425425">"Připojit"</string>
    <string name="storage_menu_unmount" msgid="681485356885955898">"Odpojit"</string>
    <string name="storage_menu_format" msgid="7690626079653152152">"Formátovat"</string>
    <string name="storage_menu_format_public" msgid="7464714208010125682">"Formátovat jako přenosné"</string>
    <string name="storage_menu_format_private" msgid="546017531835902096">"Formátovat jako interní"</string>
    <string name="storage_menu_migrate" msgid="3969621494238154294">"Migrovat data"</string>
    <string name="storage_menu_forget" msgid="6305824238997983426">"Zapomenout"</string>
    <string name="storage_menu_set_up" msgid="4263294929451685366">"Nastavit"</string>
    <string name="storage_menu_explore" msgid="4637496051816521560">"Prozkoumat"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Připojení USB k počítači"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Připojit jako"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Zařízení pro média (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Umožňuje přenášet multimediální soubory v systému Windows nebo pomocí aplikace Android File Transfer v systému Mac (další informace na stránce www.android.com/filetransfer)."</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Fotoaparát (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7406889433172511530">"Umožňuje přenos fotografií pomocí softwaru fotoaparátu a přenos jakýchkoli souborů do počítačů, které nepodporují protokol MTP"</string>
    <string name="usb_midi_title" msgid="3069990264258413994">"MIDI"</string>
    <string name="usb_midi_summary" msgid="539169474810956358">"Umožňuje aplikacím s podporou formátu MIDI spolupracovat se softwarem ke zpracování souborů MIDI prostřednictvím USB."</string>
    <string name="storage_other_users" msgid="808708845102611856">"Další uživatelé"</string>
    <string name="storage_internal_title" msgid="690771193137801021">"Úložiště zařízení"</string>
    <string name="storage_external_title" msgid="3433462910096848696">"Přenosné úložiště"</string>
    <string name="storage_volume_summary" msgid="7023441974367853372">"Použito <xliff:g id="USED">%1$s</xliff:g> z <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="storage_size_large" msgid="5691585991420946254">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_volume_used" msgid="1303803057698959872">"Použito z <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_volume_used_total" msgid="6113121714019000244">"Použito celkem z <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_mount_success" msgid="687641090137253647">"Úložiště <xliff:g id="NAME">%1$s</xliff:g> je připojeno"</string>
    <string name="storage_mount_failure" msgid="1042621107954547316">"Připojení úložiště <xliff:g id="NAME">%1$s</xliff:g> se nezdařilo"</string>
    <string name="storage_unmount_success" msgid="5737203344673441677">"Úložiště <xliff:g id="NAME">%1$s</xliff:g> bylo bezpečně odpojeno"</string>
    <string name="storage_unmount_failure" msgid="5758387106579519489">"Úložiště <xliff:g id="NAME">%1$s</xliff:g> nebylo možné bezpečně odpojit"</string>
    <string name="storage_format_success" msgid="3023144070597190555">"Úložiště <xliff:g id="NAME">%1$s</xliff:g> je naformátováno"</string>
    <string name="storage_format_failure" msgid="6032640952779735766">"Formátování úložiště <xliff:g id="NAME">%1$s</xliff:g> se nezdařilo"</string>
    <string name="storage_rename_title" msgid="8242663969839491485">"Přejmenovat úložiště"</string>
    <string name="storage_dialog_unmounted" msgid="6403320870103261477">"Toto úložiště <xliff:g id="NAME_0">^1</xliff:g> bylo bezpečně odpojeno, ale je stále k dispozici. \n\nChcete-li toto úložiště <xliff:g id="NAME_1">^1</xliff:g> použít, musíte jej nejdříve připojit."</string>
    <string name="storage_dialog_unmountable" msgid="3732209361668282254">"Toto úložiště <xliff:g id="NAME_0">^1</xliff:g> je poškozeno. \n\nChcete-li toto úložiště <xliff:g id="NAME_1">^1</xliff:g> použít, musíte jej nejdříve nastavit."</string>
    <string name="storage_dialog_unsupported" msgid="4503128224360482228">"Úložiště <xliff:g id="NAME_0">^1</xliff:g> není v tomto zařízení podporováno. \n\nChcete-li toto úložiště <xliff:g id="NAME_1">^1</xliff:g> použít s tímto zařízením, musíte jej nejdříve nastavit."</string>
    <string name="storage_internal_format_details" msgid="4018647158382548820">"Po naformátování budete moci toto úložiště <xliff:g id="NAME_0">^1</xliff:g> používat s jinými zařízeními. \n\nVeškerá data v tomto úložišti <xliff:g id="NAME_1">^1</xliff:g> budou vymazána. Doporučujeme je nejprve zálohovat. \n\n"<b>"Zálohování fotek a jiných medií"</b>" \nMediální soubory přesuňte do jiného úložiště v zařízení nebo je pomocí kabelu USB přeneste do počítače. \n\n"<b>"Zálohování aplikací"</b>" \nVšechny aplikace uložené v tomto úložišti <xliff:g id="NAME_6">^1</xliff:g> budou odinstalovány a jejich data budou vymazána. Chcete-li tyto aplikace zachovat, přesuňte je do jiného úložiště v zařízení."</string>
    <string name="storage_internal_unmount_details" msgid="3582802571684490057"><b>"Když toto úložiště <xliff:g id="NAME_0">^1</xliff:g> odpojíte, aplikace, kterou jsou v něm uloženy, přestanou fungovat a mediální soubory nebudou dostupné, dokud jej opět nevložíte."</b>\n\n"Toto úložiště <xliff:g id="NAME_1">^1</xliff:g> je naformátováno tak, aby fungovalo pouze v tomto zařízení. V jiných zařízeních fungovat nebude."</string>
    <string name="storage_internal_forget_details" msgid="9028875424669047327">"Chcete-li použít aplikace, fotky nebo data, která jsou v úložišti <xliff:g id="NAME">^1</xliff:g>, vložte jej znovu.\n\nPokud toto zařízení není k dispozici, můžete alternativně zvolit, že má být zapomenuto.\n\nPokud se rozhodnete zařízení zapomenout, veškerá data v zařízení budou navždy ztracena.\n\nAplikace můžete znovu nainstalovat později. Jejich data uložená v tomto zařízení však budou ztracena."</string>
    <string name="storage_internal_forget_confirm_title" msgid="1370847944388479245">"Zapomenout úložiště <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="1148446041396902905">"Všechny aplikace, fotky a data uložená v tomto úložišti <xliff:g id="NAME">^1</xliff:g> budou navždy ztracena."</string>
    <string name="storage_detail_apps" msgid="6141154016753507490">"Aplikace"</string>
    <string name="storage_detail_images" msgid="6950678857740634769">"Obrázky"</string>
    <string name="storage_detail_videos" msgid="2919743464827110953">"Videa"</string>
    <string name="storage_detail_audio" msgid="1197685141676483213">"Zvuk"</string>
    <string name="storage_detail_cached" msgid="8547136365247818567">"Data uložená v mezipaměti"</string>
    <string name="storage_detail_other" msgid="8404938385075638238">"Jiné"</string>
    <string name="storage_detail_explore" msgid="7911344011431568294">"Prozkoumat úložiště <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_detail_dialog_other" msgid="4894289482062047165">"Mezi ostatní soubory patří sdílené soubory uložené aplikacemi, soubory stažené z internetu nebo přes Bluetooth, soubory systému Android apod. \n\nChcete-li zobrazit celý obsah tohoto úložiště <xliff:g id="NAME">^1</xliff:g>, klepněte na Prozkoumat."</string>
    <string name="storage_detail_dialog_user" msgid="1675756743326079688">"<xliff:g id="USER_0">^1</xliff:g> může mít uložené fotky, hudbu, filmy, aplikace a další data, která v úložišti zabírají <xliff:g id="SIZE">^2</xliff:g>. \n\nChcete-li zobrazit podrobnosti, přepněte na účet uživatele <xliff:g id="USER_1">^1</xliff:g>."</string>
    <string name="storage_wizard_init_title" msgid="5085400514028585772">"Nastavte úložiště <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="4867326438945303598">"Použít jako přenosné úložiště"</string>
    <string name="storage_wizard_init_external_summary" msgid="7476105886344565074">"K přenášení fotek a dalších médií mezi zařízeními."</string>
    <string name="storage_wizard_init_internal_title" msgid="9100613534261408519">"Použít jako interní úložiště"</string>
    <string name="storage_wizard_init_internal_summary" msgid="6240417501036216410">"K ukládání libovolných dat, včetně aplikací a fotek, pouze do tohoto zařízení. Vyžaduje naformátování, které způsobí, že nebude fungovat v jiných zařízeních."</string>
    <string name="storage_wizard_format_confirm_title" msgid="2814021794538252546">"Formátovat jako interní úložiště"</string>
    <string name="storage_wizard_format_confirm_body" msgid="4401758710076806509">"Proto je nutné úložiště <xliff:g id="NAME_0">^1</xliff:g> zabezpečit pomocí formátování. \n\nPo naformátování bude úložiště <xliff:g id="NAME_1">^1</xliff:g> fungovat pouze v tomto zařízení. \n\n"<b>"Formátováním vymažete veškerá data, která jsou v tomto úložišti <xliff:g id="NAME_2">^1</xliff:g> uložena."</b>" Chcete-li ztrátě dat předejít, doporučujeme je zálohovat."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="4905690038882041566">"Formátovat jako přenosné úložiště"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="1516932692920060272">"Tato akce vyžaduje, aby úložiště <xliff:g id="NAME_0">^1</xliff:g> bylo naformátováno. \n\n"<b>"Formátováním vymažete veškerá data z úložiště <xliff:g id="NAME_1">^1</xliff:g>."</b>" Chcete-li předejít ztrátě dat, doporučujeme je zálohovat."</string>
    <string name="storage_wizard_format_confirm_next" msgid="2774557300531702572">"Vymazat a naformátovat"</string>
    <string name="storage_wizard_format_progress_title" msgid="6487352396450582292">"Formátování úložiště <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="4445041233802828430">"Během formátování úložiště <xliff:g id="NAME">^1</xliff:g> neodpojujte."</string>
    <string name="storage_wizard_migrate_title" msgid="1363078147938160407">"Přesuňte data do nového úložiště"</string>
    <string name="storage_wizard_migrate_body" msgid="890751699549542345">"Do tohoto nového úložiště <xliff:g id="NAME">^1</xliff:g> můžete přesunout fotky, soubory a některé aplikace. \n\nPřesun bude trvat <xliff:g id="TIME">^2</xliff:g> a v interním úložišti uvolní <xliff:g id="SIZE">^3</xliff:g>. Během přesunu nebudou některé aplikace fungovat."</string>
    <string name="storage_wizard_migrate_now" msgid="4523444323744239143">"Přesunout"</string>
    <string name="storage_wizard_migrate_later" msgid="3173482328116026253">"Přesunout později"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="8564833529613286965">"Přesun dat"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="4212060581792135962"><b>"Doba přesunu: cca <xliff:g id="TIME">^1</xliff:g>. <xliff:g id="NAME">^3</xliff:g> uvolní <xliff:g id="SIZE">^2</xliff:g>."</b></string>
    <string name="storage_wizard_migrate_confirm_next" msgid="5509475628423823202">"Přesunout"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="1665479429044202868">"Probíhá přesun dat…"</string>
    <string name="storage_wizard_migrate_details" msgid="3709728824651136227">"Během přesunu: \n• Neodpojujte <xliff:g id="NAME">^1</xliff:g>. \n• Některé aplikace nebudou fungovat správně. \n• Udržujte zařízení nabité."</string>
    <string name="storage_wizard_ready_title" msgid="5381632402953258267">"Úložiště <xliff:g id="NAME">^1</xliff:g> je připraveno"</string>
    <string name="storage_wizard_ready_external_body" msgid="2879508114260597474">"Nyní do úložiště <xliff:g id="NAME">^1</xliff:g> můžete ukládat fotky a další média."</string>
    <string name="storage_wizard_ready_internal_body" msgid="122532674037860197">"Nové úložiště <xliff:g id="NAME">^1</xliff:g> již funguje. \n\nChcete-li do tohoto zařízení přesunout fotky, soubory a data aplikací, přejděte do Nastavení &gt; Úložiště."</string>
    <string name="storage_wizard_move_confirm_title" msgid="292782012677890250">"Přesuňte aplikaci <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="5176432115206478941">"Přesunutí aplikace <xliff:g id="APP">^1</xliff:g> a jejích dat do úložiště <xliff:g id="NAME_0">^2</xliff:g> bude trvat jen chvíli. Aplikaci bude možné používat až po dokončení přesunu. \n\nÚložiště <xliff:g id="NAME_1">^2</xliff:g> během přesunu neodpojujte."</string>
    <string name="storage_wizard_move_progress_title" msgid="4443920302548035674">"Probíhá přesun aplikace <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="7802577486578105609">"Úložiště <xliff:g id="NAME">^1</xliff:g> během přesunu nevysouvejte. \n\nAplikace <xliff:g id="APP">^2</xliff:g> bude v tomto zařízení k dispozici až po dokončení přesunu."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="542047237524588792">"Zrušit přesun"</string>
    <string name="storage_wizard_slow_body" msgid="8010127667184768025">"Toto zařízení <xliff:g id="NAME_0">^1</xliff:g> je pravděpodobně pomalé. \n\nMůžete pokračovat, ale aplikace přesunuté do tohoto umístění budou mít prodlevy a přenosy dat mohou trvat delší dobu. \n\nZkuste použít rychlejší zařízení <xliff:g id="NAME_1">^1</xliff:g>, které zajistí vyšší výkon."</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Stav baterie"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Nabití baterie"</string>
    <string name="apn_settings" msgid="3743170484827528406">"Přístupové body"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Upravit přístupový bod"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Nenastaveno"</string>
    <string name="apn_name" msgid="4115580098369824123">"Název"</string>
    <string name="apn_apn" msgid="2479425126733513353">"Název přístupového bodu"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Proxy"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Port"</string>
    <string name="apn_user" msgid="455637547356117761">"Uživatelské jméno"</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">"Proxy server 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 ověření"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Žádné"</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 nebo CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Typ přístupového bodu"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"Protokol APN"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protokol APN pro roaming"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Povolit/zakázat APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"Přístupový bod je povolen"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"Přístupový bod je zakázán"</string>
    <string name="bearer" msgid="594270280031923558">"Nositel"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Typ MVNO"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Hodnota MVNO"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Smazat přístupový bod"</string>
    <string name="menu_new" msgid="3014205883303921729">"Nový přístupový bod"</string>
    <string name="menu_save" msgid="8109345640668285399">"Uložit"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Zahodit"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="5508155943840201232">"Pole Jméno nesmí být prázdné."</string>
    <string name="error_apn_empty" msgid="4932211013600863642">"Název přístupového bodu nesmí být prázdný."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"Pole MCC musí obsahovat 3 číslice."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Pole MNC musí obsahovat 2 nebo 3 číslice."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Obnovování výchozích nastavení přístupového bodu"</string>
    <string name="menu_restore" msgid="8260067415075573273">"Obnovit výchozí"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Výchozí nastavení přístupového bodu bylo obnoveno."</string>
    <string name="reset_network_title" msgid="4557113742173895074">"Obnovení nastavení sítě"</string>
    <string name="reset_network_desc" msgid="581668983587311282">"Tímto obnovíte nastavení všech sítí, včetně následujících:\n\n"<li>"Wi‑Fi"</li>\n<li>"mobilní datové připojení"</li>\n<li>"Bluetooth"</li></string>
    <string name="reset_network_button_text" msgid="2035676527471089853">"Obnovit nastavení"</string>
    <string name="reset_network_final_desc" msgid="6388371121099245116">"Chcete resetovat všechna nastavení sítí? Tuto akci nelze vrátit zpět."</string>
    <string name="reset_network_final_button_text" msgid="1797434793741744635">"Obnovit nastavení"</string>
    <string name="reset_network_confirm_title" msgid="1759888886976962773">"Resetovat?"</string>
    <string name="network_reset_not_available" msgid="7188610385577164676">"Pro tohoto uživatele resetování sítě není k dispozici"</string>
    <string name="reset_network_complete_toast" msgid="787829973559541880">"Nastavení sítí bylo resetováno"</string>
    <string name="device_reset_title" msgid="2384019005638768076">"Resetovat zařízení"</string>
    <string name="master_clear_title" msgid="5907939616087039756">"Obnovení továrních dat"</string>
    <string name="master_clear_desc" product="tablet" msgid="9146059417023157222">"Tato akce smaže veškerá data z "<b>"interního úložiště"</b>" tabletu, mj. i:\n\n"<li>"váš účet Google,"</li>\n<li>"nastavení a data systému a aplikací,"</li>\n<li>"stažené aplikace."</li></string>
    <string name="master_clear_desc" product="default" msgid="4800386183314202571">"Tato akce smaže veškerá data z "<b>"interního úložiště"</b>" telefonu, mj. i:\n\n"<li>"váš účet Google,"</li>\n<li>"nastavení a data systému a aplikací,"</li>\n<li>"stažené aplikace."</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Aktuálně jste přihlášeni k těmto účtům:\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="5161423070702470742">\n\n"V tomto zařízení jsou přítomni další uživatelé.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Hudba"</li>\n<li>"Fotky"</li>\n<li>"další uživatelské údaje"</li></string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Chcete-li smazat také hudbu, obrázky a další uživatelská data, je potřeba vymazat "<b>"úložiště USB"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Chcete-li smazat také hudbu, obrázky a další uživatelská data, je potřeba vymazat "<b>"kartu SD"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Smazat úložiště USB"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Smazat kartu SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Smazat všechna data v interním úložišti USB, například hudbu a fotografie."</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Smazat všechna data na kartě SD, například hudbu a fotografie."</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Resetovat tablet"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Resetovat telefon"</string>
    <string name="master_clear_final_desc" msgid="7318683914280403086">"Chcete vymazat všechny osobní údaje a stažené aplikace? Tuto akci nelze vrátit zpět."</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Vymazat vše"</string>
    <string name="master_clear_failed" msgid="2503230016394586353">"Pokus o obnovení se nezdařil, protože služba System Clear není dostupná."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Obnovit?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Pro tohoto uživatele není obnovení továrního nastavení dostupné"</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Mazání"</string>
    <string name="master_clear_progress_text" msgid="6559096229480527510">"Prosím čekejte..."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Nastavení hovorů"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Nastavení hlasové schránky, přesměrování a čekání hovorů a ID volajícího"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Připojení přes USB"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Přenosný hotspot"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Připojení přes Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Sdílené připojení"</string>
    <string name="tether_settings_title_all" msgid="8356136101061143841">"Sdílené připojení a přenosný hotspot"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Připojení přes USB"</string>
    <string name="usb_tethering_available_subtext" msgid="156779271296152605">"Připojeno přes USB. Zapnutím této volby vytvoříte sdílené připojení."</string>
    <string name="usb_tethering_active_subtext" msgid="8916210851136467042">"Sdíleno"</string>
    <string name="usb_tethering_storage_active_subtext" msgid="8427089411146908205">"Nelze sdílet datové připojení, pokud se používá úložiště USB"</string>
    <string name="usb_tethering_unavailable_subtext" msgid="1044622421184007254">"Připojení USB není k dispozici"</string>
    <string name="usb_tethering_turnon_subtext" msgid="4748616058219273033">"Chcete-li úložiště USB zapnout, připojte jej"</string>
    <string name="usb_tethering_errored_subtext" msgid="1377574819427841992">"Chyba sdíleného připojení přes USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Připojení přes Bluetooth"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="4328374808439440517">"Internetové připojení tabletu je sdíleno."</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="7451579908917710359">"Internetové připojení tohoto telefonu je sdíleno"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="7296104766087335891">"Internetové připojení tabletu je sdíleno s 1 zařízením."</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="2785474869740805972">"Internetové připojení telefonu je sdíleno s 1 zařízením."</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="7345108029216525495">"Internet. připojení tabletu je sdíleno. Poč. zařízení: <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="2992288063706153665">"Internet. připojení telefonu je sdíleno. Poč. zařízení: <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="6630416508030836214">"Sdílení připojení k internetu tohoto zařízení <xliff:g id="DEVICE_NAME">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="3737828501935728137">"Internetové připojení tabletu není sdíleno."</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="9099562374002272901">"Internetové připojení tohoto telefonu není sdíleno"</string>
    <string name="bluetooth_tethering_errored_subtext" msgid="4926566308991142264">"Není sdíleno"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="2135590598511178690">"Připojení lze sdílet s nejvýše <xliff:g id="MAXCONNECTION">%1$d</xliff:g> zařízeními."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"U zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude ukončeno sdílené připojení."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Nápověda"</string>
    <string name="network_settings_title" msgid="4871233236744292831">"Mobilní sítě"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Mobilní tarif"</string>
    <string name="sms_application_title" msgid="4903928270533250448">"Aplikace pro SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Chcete změnit aplikaci SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Chcete pro zprávy SMS používat aplikaci <xliff:g id="NEW_APP">%1$s</xliff:g> místo aplikace <xliff:g id="CURRENT_APP">%2$s</xliff:g>?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Chcete pro zprávy SMS používat aplikaci <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"Změnit nastavení Google Wi-Fi Assistant?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"Chcete spravovat síťová připojení pomocí aplikace <xliff:g id="NEW_APP">%1$s</xliff:g> namísto aplikace <xliff:g id="CURRENT_APP">%2$s</xliff:g>?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="7444620909047611601">"Chcete spravovat síťová připojení pomocí aplikace <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Operátor SIM karty není znám"</string>
    <string name="mobile_no_provisioning_url" msgid="2399426808423775711">"%1$s nemá žádný známý web pro správu účtů."</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Vložte SIM kartu a restartujte zařízení."</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Připojte se prosím k internetu."</string>
    <string name="location_title" msgid="1029961368397484576">"Moje poloha"</string>
    <string name="managed_profile_location_category" msgid="6992546457880004735">"Pracovní profil"</string>
    <string name="managed_profile_location_switch_title" msgid="6712332547063039683">"Umístění pracovního profilu"</string>
    <string name="managed_profile_location_switch_lockdown" msgid="3851708343340350369">"Vypnuto vaší společností"</string>
    <string name="location_mode_title" msgid="3982009713118421689">"Režim určování polohy"</string>
    <string name="location_mode_high_accuracy_title" msgid="8241802585110932849">"Vysoká přesnost"</string>
    <string name="location_mode_battery_saving_title" msgid="711273645208158637">"Úspora baterie"</string>
    <string name="location_mode_sensors_only_title" msgid="3040366132175435160">"Pouze zařízení"</string>
    <string name="location_mode_location_off_title" msgid="2829713015012529465">"Poloha vypnuta"</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Nedávné žádosti o určení polohy"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"V poslední době žádné aplikace o polohu nepožádaly."</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Služby určování polohy"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Vysoké využívání baterie"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Nízké využívání baterie"</string>
    <string name="location_mode_screen_title" msgid="4528716772270246542">"Určování polohy"</string>
    <string name="location_mode_high_accuracy_description" msgid="5703350404315028607">"K určování polohy používat GPS, Wi-Fi, Bluetooth nebo mobilní sítě"</string>
    <string name="location_mode_battery_saving_description" msgid="8361848607963121770">"K určování polohy používat Wi-Fi, Bluetooth nebo mobilní sítě"</string>
    <string name="location_mode_sensors_only_description" msgid="788127681455735699">"K určování polohy používat GPS"</string>
    <string name="location_menu_scanning" msgid="8536245838478802959">"Skenování"</string>
    <string name="location_scanning_screen_title" msgid="4408076862929611554">"Skenování"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="6216705505621183645">"Vyhledávání Wi‑Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="8036382029606868081">"Umožňuje zlepšit přesnost určování polohy tím, že systémové aplikace a služby budou vyhledávat sítě Wi-Fi neustále."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="5444989508204520019">"Vyhledávání Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="8602726521250591852">"Umožňuje zlepšit přesnost určování polohy tím, že systémové aplikace a služby budou vyhledávat zařízení Bluetooth neustále."</string>
    <string name="location_network_based" msgid="6010456018401296590">"Poloha z Wi-Fi a mobilních sítí"</string>
    <string name="location_neighborhood_level" msgid="5141318121229984788">"Povolit aplikacím používat službu určování polohy Google a rychleji odhadovat vaši polohu. Anonymní data budou sbírána a odesílána Googlu."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Poloha určená sítí Wi-Fi"</string>
    <string name="location_gps" msgid="8392461023569708478">"Satelity GPS"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Povolit aplikacím ve vašem tabletu určovat polohu pomocí GPS"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Povolit aplikacím ve vašem telefonu určovat polohu pomocí GPS"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Použít systém A-GPS"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Vylepšit funkčnost GPS pomocí serveru (deaktivací této funkce snížíte využití sítě)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Vylepšit funkčnost GPS pomocí serveru (zrušením této funkce zvýšíte výkon GPS)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Poloha a vyhledávání"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Povolit Googlu použít vaši polohu ke zlepšení výsledků vyhledávání a dalších služeb"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Přístup k údajům o mé poloze"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Povolit aplikacím, které o to požádaly, používat údaje o poloze"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Zdroje polohy"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"Informace o tabletu"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"Informace o telefonu"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Zobrazí právní informace, stav a verzi softwaru"</string>
    <string name="legal_information" msgid="5769301644270604095">"Právní informace"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Přispěvatelé"</string>
    <string name="regulatory_information" msgid="5695464367088752150">"Regulační informace"</string>
    <string name="copyright_title" msgid="865906688917260647">"Autorská práva"</string>
    <string name="license_title" msgid="1990487604356037871">"Licence"</string>
    <string name="terms_title" msgid="7697580845616764642">"Smluvní podmínky"</string>
    <string name="webview_license_title" msgid="2813507464175738967">"Systémová licence WebView"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Tapety"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Poskytovatelé satelitních snímků:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_license_activity_title" msgid="7553683406244228650">"Licence open source"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Při načítání licencí došlo k chybě."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Načítání..."</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Bezpečnostní informace"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Bezpečnostní informace"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="250674109915859456">"Datové připojení momentálně není k dispozici. Chcete-li tyto informace zobrazit, přejděte z libovolného počítače připojeného k internetu na stránku %s."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Načítání..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Zvolte heslo"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="6949761069941694050">"Vyberte gesto"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Zvolte 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 své gesto"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="49038294648213197">"Potvrďte kód PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="5140892109439191415">"Hesla nejsou shodná"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="7226244811505606217">"Kódy PIN nejsou shodné"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Výběr odemknutí"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Heslo bylo nastaveno"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"Kód PIN byl nastaven"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Gesto bylo nastaveno"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7050256155547273836">"Chcete-li pokračovat, zadejte gesto zařízení."</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="1072670959803859869">"Chcete-li pokračovat, zadejte PIN zařízení."</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="1022239625083264596">"Chcete-li pokračovat, zadejte heslo zařízení."</string>
    <string name="lockpassword_invalid_pin" msgid="15588049067548470">"Nesprávný kód PIN"</string>
    <string name="lockpassword_invalid_password" msgid="4038507398784975200">"Nesprávné heslo"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="1745247595356012176">"Nesprávné gesto"</string>
    <string name="lock_settings_title" msgid="4213839087748988686">"Zabezpečení zařízení"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Změna bezpečnostního gesta"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Změna bezpečnostního kódu PIN"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Proveďte gesto odemknutí"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Nápovědu zobrazíte stisknutím klávesy Menu."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Na závěr zdvihněte prst z obrazovky"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Spojte alespoň <xliff:g id="NUMBER">%d</xliff:g> tečky. Zkuste to znovu."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Gesto bylo zaznamenáno"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Potvrďte své gesto"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Nové bezpečnostní gesto"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Potvrdit"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Nakreslit znovu"</string>
    <string name="lockpattern_retry_button_text" msgid="3480423193273588166">"Vymazat"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Pokračovat"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Gesto odemknutí"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Požadovat gesto"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Obrazovku je třeba odemknout gestem ruky."</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Zobrazovat gesto"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="8898518337442601027">"Při dotyku vibrovat"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Vypínač zamkne zařízení"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"Pokud odemknutí není udržováno funkcí <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Nastavení bezpečnostního gesta"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Změna bezpečnostního gesta"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Gesto odemknutí obrazovky proveďte tímto způsobem"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="6909161623701848863">"Příliš mnoho neplatných pokusů. Zkuste to znovu za <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Aplikace není v telefonu nainstalována."</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Spravovat aplikace"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Umožňuje spravovat a odebírat instalované aplikace"</string>
    <string name="applications_settings" msgid="1721442176406964682">"Aplikace"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Správa aplikací a klávesových zkratek rychlého spuštění"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Nastavení aplikace"</string>
    <string name="install_applications" msgid="4872012136210802181">"Neznámé zdroje"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Povolit všechny zdroje aplikací"</string>
    <string name="install_unknown_applications_title" msgid="663831043139080992">"Umožňuje instalovat aplikace z jiných zdrojů než Google Play."</string>
    <string name="install_unknown_applications" msgid="176855644862942064">"Povolit instalaci aplikací z neznámých zdrojů"</string>
    <string name="install_all_warning" product="tablet" msgid="3263360446508268880">"Data zařízení a osobní údaje jsou zranitelnější vůči útoku aplikací, které pochází z neznámých zdrojů. Souhlasíte s tím, že jste výhradně odpovědní za případné škody na zařízení a ztráty dat způsobené používáním těchto aplikací."</string>
    <string name="install_all_warning" product="default" msgid="8113734576826384682">"Váš telefon a osobní údaje jsou zranitelnější vůči útoku aplikací, které pochází z neznámých zdrojů. Souhlasíte s tím, že nesete osobní odpovědnost za jakékoli škody způsobené na vašem telefonu nebo za ztrátu dat v důsledku používání těchto aplikací."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Upřesnit nastavení"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Povolit další možnosti nastavení"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Informace o aplikaci"</string>
    <string name="storage_label" msgid="8700867073480107253">"Úložiště"</string>
    <string name="auto_launch_label" msgid="2669236885531442195">"Otevírat ve výchozím nastavení"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Výchozí aplikace"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Kompatibilita s obrazovkou"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Oprávnění"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Mezipaměť"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Vymazat mezipaměť"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Mezipaměť"</string>
    <string name="controls_label" msgid="7611113077086853799">"Ovládací prvky"</string>
    <string name="force_stop" msgid="7435006169872876756">"Vynutit ukončení"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Celkem"</string>
    <string name="application_size_label" msgid="8494609207373874267">"Aplikace"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Aplikace úložiště USB"</string>
    <string name="data_size_label" msgid="8679376373625710107">"Data"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Data úložiště USB"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"Karta SD"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Odinstalovat"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Odinstalovat pro všechny uživatele"</string>
    <string name="install_text" msgid="884360662922471113">"Instalovat"</string>
    <string name="disable_text" msgid="6544054052049395202">"Deaktivovat"</string>
    <string name="enable_text" msgid="9217362512327828987">"Aktivovat"</string>
    <string name="clear_user_data_text" msgid="5597622864770098388">"Vymazat data"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Odinstalovat aktualizace"</string>
    <string name="auto_launch_enable_text" msgid="4275746249511874845">"Aplikace byla nastavena, aby se pro některé akce spouštěla jako výchozí."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="566822577792032925">"Této aplikaci jste povolili vytváření widgetů a přístup k jejich datům."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Není nastavena jako výchozí pro žádné akce"</string>
    <string name="clear_activities" msgid="7408923511535174430">"Vymazat výchozí nastavení"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Tato aplikace nejspíš není určena pro vaši obrazovku. Zde můžete nastavit, jak se aplikace obrazovce přizpůsobí."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Dotázat se při spuštění"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Upravit velikost aplikace"</string>
    <string name="unknown" msgid="1592123443519355854">"Neznámé"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Seřadit podle jména"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Řadit podle velikosti"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Zobrazit spuštěné služby"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Zobrazit mezipaměť"</string>
    <string name="default_emergency_app" msgid="1951760659640369980">"Aplikace k příjmu výstražných zpráv"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Obnovit nastavení aplikací"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Obnovit nastavení aplikací?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"Tímto resetujete všechna nastavení následujících položek:\n\n "<li>"deaktivované aplikace,"</li>\n" "<li>"deaktivovaná oznámení aplikací,"</li>\n" "<li>"výchozí aplikace pro různé akce,"</li>\n" "<li>"omezení datových přenosů na pozadí pro aplikace,"</li>\n" "<li>"veškerá omezení oprávnění."</li>\n\n" Nepřijdete o žádná data aplikací."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Obnovit aplikace"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Správa paměti"</string>
    <string name="filter" msgid="2018011724373033887">"Filtrovat"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Vyberte možnosti filtru"</string>
    <string name="filter_apps_all" msgid="5142129378749391876">"Vše"</string>
    <string name="filter_apps_disabled" msgid="5364447573326472890">"Deaktivované"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Stažené"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Spuštěné"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Úložiště USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Na kartě SD"</string>
    <string name="disabled" msgid="9206776641295849915">"Deaktivováno"</string>
    <string name="not_installed" msgid="2797554494953450291">"Pro tohoto uživ. nenainstal."</string>
    <string name="no_applications" msgid="7336588977497084921">"Žádné aplikace"</string>
    <string name="internal_storage" msgid="1584700623164275282">"Interní úložiště"</string>
    <string name="internal_storage_sentence" msgid="889098931914857143">"interní úložiště"</string>
    <string name="sd_card_storage" product="nosdcard" msgid="2673203150465132465">"Úložiště USB"</string>
    <string name="sd_card_storage" product="default" msgid="7623513618171928235">"Karta SD"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Přepočítávání velikosti..."</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Vymazat data aplikace?"</string>
    <string name="clear_data_dlg_text" msgid="3951297329833822490">"Veškerá data (všechny soubory, nastavení, účty, databáze apod.) této aplikace budou trvale vymazána."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"OK"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Zrušit"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="4893589904687340011">"Aplikaci se nepodařilo najít na seznamu nainstalovaných aplikací."</string>
    <string name="clear_data_failed" msgid="7214074331627422248">"Nelze vymazat data aplikace."</string>
    <string name="app_factory_reset_dlg_title" msgid="7441012826373143593">"Odinstalovat aktualizace?"</string>
    <string name="app_factory_reset_dlg_text" msgid="6371247225487725860">"Všechny aktualizace této aplikace systému Android budou odinstalovány."</string>
    <string name="clear_failed_dlg_title" msgid="2387060805294783175">"Vymazat data"</string>
    <string name="clear_failed_dlg_text" msgid="5464475937929941008">"Nepodařilo se vymazat data aplikace."</string>
    <string name="security_settings_desc" product="tablet" msgid="1292421279262430109">"Tato aplikace má přístup k následujícím funkcím tabletu:"</string>
    <string name="security_settings_desc" product="default" msgid="61749028818785244">"Tato aplikace má přístup k následujícím funkcím telefonu:"</string>
    <string name="security_settings_desc_multi" product="tablet" msgid="7300932212437084403">"Tato aplikace může ve vašem tabletu používat následující oprávnění. Chcete-li zvýšit výkon a snížit využití paměti, některá tato oprávnění jsou dostupná v aplikaci <xliff:g id="BASE_APP_NAME">%1$s</xliff:g>, která se spouští v rámci stejného procesu jako aplikace <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="security_settings_desc_multi" product="default" msgid="6610268420793984752">"Tato aplikace může ve vašem telefonu používat následující oprávnění. Chcete-li zvýšit výkon a snížit využití paměti, některá tato oprávnění jsou dostupná v aplikaci <xliff:g id="BASE_APP_NAME">%1$s</xliff:g>, která se spouští v rámci stejného procesu jako aplikace <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> a <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="5925635036718502724">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> a <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="4333907712038448660">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="7556692394478220814">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="security_settings_billing_desc" msgid="8061019011821282358">"Tato aplikace vám může účtovat poplatky:"</string>
    <string name="security_settings_premium_sms_desc" msgid="8734171334263713717">"Odesílání prémiových zpráv SMS"</string>
    <string name="computing_size" msgid="1599186977475211186">"Probíhá výpočet…"</string>
    <string name="invalid_size_value" msgid="1582744272718752951">"Nepodařilo se určit velikost balíčku."</string>
    <string name="empty_list_msg" msgid="3552095537348807772">"Žádné aplikace třetích stran nejsou nainstalovány."</string>
    <string name="version_text" msgid="9189073826278676425">"verze <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Přesunout"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Přesunout do tabletu"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Přesunout do telefonu"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Přesunout do úlož. USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Přesunout na kartu SD"</string>
    <string name="moving" msgid="6431016143218876491">"Přesouvání"</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Nedostatek místa v úložišti."</string>
    <string name="does_not_exist" msgid="1501243985586067053">"Aplikace neexistuje."</string>
    <string name="app_forward_locked" msgid="6331564656683790866">"Aplikace je chráněna proti kopírování."</string>
    <string name="invalid_location" msgid="4354595459063675191">"Umístění instalace není platné."</string>
    <string name="system_package" msgid="1352722848400644991">"Aktualizace systému nelze nainstalovat na externí média."</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Chcete vynutit zastavení?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Vynucené zastavení může způsobit nepředvídatelné chování aplikace."</string>
    <string name="move_app_failed_dlg_title" msgid="1282561064082384192"></string>
    <string name="move_app_failed_dlg_text" msgid="187885379493011720">"Přesunutí aplikace se nezdařilo. <xliff:g id="REASON">%1$s</xliff:g>"</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Preferované umístění pro instalaci"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Změna preferovaného umístění pro instalaci nových aplikací"</string>
    <string name="app_disable_dlg_title" msgid="3916469657537695436">"Deaktivovat integrovanou aplikaci"</string>
    <string name="app_disable_dlg_positive" msgid="7375627244201714263">"Deaktivovat aplikaci"</string>
    <string name="app_disable_dlg_text" msgid="7824930380425568584">"Pokud aplikaci deaktivujete, ostatní aplikace nemusejí fungovat správně."</string>
    <string name="app_special_disable_dlg_title" msgid="2690148680327142674">"Vymazat data a deaktivovat aplikaci?"</string>
    <string name="app_special_disable_dlg_text" msgid="1007112763234313018">"Pokud aplikaci deaktivujete, ostatní aplikace nemusejí fungovat správně. Také budou smazána data."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Vypnout oznámení?"</string>
    <string name="app_disable_notifications_dlg_text" msgid="5088484670924769845">"Pokud v této aplikaci vypnete oznámení, můžete přijít o důležitá upozornění a aktuality."</string>
    <string name="app_ops_settings" msgid="5108481883575527511">"Operace aplikací"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"Spuštěno"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Nebylo použito)"</string>
    <string name="no_default_apps" msgid="2915315663141025400">"Žádné výchozí aplikace"</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Využití úložiště"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Zobrazit aplikacemi používané úložiště"</string>
    <string name="runningservices_settings_title" msgid="8097287939865165213">"Spuštěné služby"</string>
    <string name="runningservices_settings_summary" msgid="854608995821032748">"Umožňuje zobrazit a ovládat aktuálně spuštěné služby"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Probíhá restartování"</string>
    <string name="cached" msgid="1059590879740175019">"Proces na pozadí v mezipaměti"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Nic není spuštěno."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Spuštěno aplikací."</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"Volno: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"Využito: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Uživatel: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Odebraný uživatel"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_header_title" msgid="6588371727640789560">"Paměť zařízení"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Využití paměti RAM aplikacemi"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Systém"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Aplikace"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"Volná"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Využito"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"V mezipaměti"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Spuštěná aplikace"</string>
    <string name="no_services" msgid="7133900764462288263">"Neaktivní"</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">"Zastavit"</string>
    <string name="service_manage" msgid="1876642087421959194">"Nastavení"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Tato služba byla spuštěna svou aplikací. Pokud ji zastavíte, může dojít k selhání aplikace."</string>
    <string name="heavy_weight_stop_description" msgid="6050413065144035971">"Tuto aplikaci nemůžete bezpečně ukončit. Mohlo by dojít ke ztrátě části vaší aktuální práce."</string>
    <string name="background_process_stop_description" msgid="3834163804031287685">"Toto je starý proces aplikace, který je spuštěn pro případ, že bude znovu potřeba. Zpravidla není důvod jej zastavovat."</string>
    <string name="service_manage_description" msgid="7050092269951613102">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: právě se používá. Ovládací prvky zobrazte dotykem na Nastavení."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Hlavní proces, který se používá."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Služba <xliff:g id="COMP_NAME">%1$s</xliff:g> se používá."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Poskytovatel <xliff:g id="COMP_NAME">%1$s</xliff:g> se používá."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Zastavit systémovou službu?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Pokud tuto službu zastavíte, může se stát, že některé funkce telefonu nebudou fungovat správně, dokud telefon nevypnete a opět nezapnete."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Pokud tuto službu zastavíte, může se stát, že některé funkce tabletu nebudou fungovat správně, dokud telefon nevypnete a opět nezapnete."</string>
    <string name="language_settings" msgid="5292716747264442359">"Jazyk a zadávání"</string>
    <string name="language_keyboard_settings_title" msgid="243220021717425813">"Jazyk a zadávání"</string>
    <string name="language_settings_category" msgid="2288258489940617043">"Nastavení jazyka"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Klávesnice a metody zadávání"</string>
    <string name="phone_language" msgid="8870144109924299673">"Jazyk"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Automatické nahrazování"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Opravovat pravopisné chyby"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Velká písmena automaticky"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"První písmeno ve větě je automaticky velké"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Automatická interpunkce"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Nastavení fyzické klávesnice"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Znak „.“ lze vložit dvojím stisknutím klávesy Mezerník."</string>
    <string name="show_password" msgid="3001113966880559611">"Zobrazovat hesla"</string>
    <string name="ime_security_warning" msgid="4135828934735934248">"Prostřednictvím této vstupní metody zadávání dat lze shromažďovat zadaný text včetně osobních údajů, jako jsou hesla a čísla platebních karet. Metoda je poskytována aplikací <xliff:g id="IME_APPLICATION_NAME">%1$s</xliff:g>. Chcete tuto metodu zadávání dat použít?"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Prostřednictvím této kontroly pravopisu lze shromažďovat zadaný text včetně osobních údajů, jako jsou hesla a čísla kreditních karet. Kontrola pravopisu je součástí aplikace <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Chcete tuto kontrolu pravopisu použít?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Nastavení"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Jazyk"</string>
    <string name="failed_to_open_app_settings_toast" msgid="1251067459298072462">"Nastavení aplikace <xliff:g id="SPELL_APPLICATION_NAME">%1$s</xliff:g> se nepodařilo otevřít"</string>
    <string name="pointer_settings_category" msgid="8183819795164034286">"Myš/trackpad"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Rychlost kurzoru"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Herní ovladače"</string>
    <string name="vibrate_input_devices" msgid="2599591466928793082">"Použít vibrace"</string>
    <string name="vibrate_input_devices_summary" msgid="4595570516865299153">"Přesměrovat vibrace do herního ovladače, je-li připojen."</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Zvolte rozložení klávesnice"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Nastavit rozvržení klávesnice"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Přepněte klávesami ctrl+mezerník"</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Výchozí"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Rozložení klávesnice"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Vlastní slovník"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Přidat"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Přidat do slovníku"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Fráze"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Více možností"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Méně 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">"Zkratka:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Jazyk:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Napište slovo"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Volitelná zkratka"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Upravit slovo"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Upravit"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Smazat"</string>
    <string name="user_dict_settings_empty_text" msgid="996593969349827966">"V uživatelském slovníku nejsou žádná slova. Slovo můžete přidat stisknutím tlačítka Přidat (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Pro všechny jazyky"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Další jazyky..."</string>
    <string name="testing" msgid="6584352735303604146">"Testování"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informace o tabletu"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Informace o telefonu"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Zadávání textu"</string>
    <string name="input_method" msgid="5434026103176856164">"Metoda zadávání dat"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Aktuální klávesnice"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Výběr metody zadávání"</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 zobrazovat"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Vždy skrývat"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Nastavit metody zadávání"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Nastavení"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Nastavení"</string>
    <string name="active_input_method_subtypes" msgid="3596398805424733238">"Aktivní metody zadávání"</string>
    <string name="use_system_language_to_select_input_method_subtypes" msgid="3346751753141428573">"Použít systémový jazyk"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Nastavení modulu <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Vybrat aktivní metody zadávání"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Nastavení softwarové klávesnice"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Fyzická klávesnice"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Nastavení fyzické klávesnice"</string>
    <string name="development_settings_title" msgid="215179176067683667">"Pro vývojáře"</string>
    <string name="development_settings_summary" msgid="1815795401632854041">"Umožňuje nastavit možnosti pro vývoj aplikací"</string>
    <string name="development_settings_not_available" msgid="4308569041701535607">"Pro tohoto uživatele jsou možnosti vývojáře nedostupné."</string>
    <string name="vpn_settings_not_available" msgid="956841430176985598">"Nastavení sítě VPN pro tohoto uživatele není dostupné."</string>
    <string name="tethering_settings_not_available" msgid="6765770438438291012">"Nastavení sdíleného připojení pro tohoto uživatele není dostupné."</string>
    <string name="apn_settings_not_available" msgid="7873729032165324000">"Nastavení přístupového bodu pro tohoto uživatele není dostupné."</string>
    <string name="enable_adb" msgid="7982306934419797485">"Ladění USB"</string>
    <string name="enable_adb_summary" msgid="4881186971746056635">"Povolit režim ladění s připojeným zařízením USB"</string>
    <string name="clear_adb_keys" msgid="4038889221503122743">"Zrušit autorizace k ladění USB"</string>
    <string name="bugreport_in_power" msgid="7923901846375587241">"Zástupce hlášení chyb"</string>
    <string name="bugreport_in_power_summary" msgid="1778455732762984579">"Zobrazit v hlavní nabídce tlačítko k vygenerování chybového hlášení"</string>
    <string name="keep_screen_on" msgid="1146389631208760344">"Nevypínat obrazovku"</string>
    <string name="keep_screen_on_summary" msgid="2173114350754293009">"Obrazovka se při nabíjení nepřepne do režimu spánku"</string>
    <string name="bt_hci_snoop_log" msgid="3340699311158865670">"Povolit protokol Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_summary" msgid="730247028210113851">"Zachytit všechny pakety Bluetooth HCI do souboru"</string>
    <string name="oem_unlock_enable" msgid="6040763321967327691">"Odemknutí OEM"</string>
    <string name="oem_unlock_enable_summary" msgid="4720281828891618376">"Povolit odemknutí zavaděče"</string>
    <string name="confirm_enable_oem_unlock_title" msgid="4802157344812385674">"Povolit odemknutí OEM?"</string>
    <string name="confirm_enable_oem_unlock_text" msgid="5517144575601647022">"UPOZORNĚNÍ: Pokud bude toto nastavení zapnuto, nebudou v tomto zařízení fungovat funkce ochrany zařízení."</string>
    <string name="select_logd_size_title" msgid="7433137108348553508">"Vyrovnávací paměť protokol. nástroje"</string>
    <string name="select_logd_size_dialog_title" msgid="1206769310236476760">"Velikost vyrovnávací paměti protokol. nástroje"</string>
    <string name="mock_location_app" msgid="7966220972812881854">"Vybrat aplikaci k simulování polohy"</string>
    <string name="mock_location_app_not_set" msgid="809543285495344223">"Aplikace k simulování polohy není nastavena"</string>
    <string name="mock_location_app_set" msgid="8966420655295102685">"Aplikace k simulování polohy: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="debug_view_attributes" msgid="6485448367803310384">"Kontrola atributu zobrazení"</string>
    <string name="debug_networking_category" msgid="7044075693643009662">"Sítě"</string>
    <string name="wifi_display_certification" msgid="8611569543791307533">"Certifikace bezdrát. displeje"</string>
    <string name="wifi_verbose_logging" msgid="4203729756047242344">"Podrobné protokolování Wi‑Fi"</string>
    <string name="wifi_aggressive_handover" msgid="9194078645887480917">"Agres. předání z Wi-Fi na mobilní síť"</string>
    <string name="wifi_allow_scan_with_traffic" msgid="3601853081178265786">"Vždy povolit Wi-Fi roaming"</string>
    <string name="legacy_dhcp_client" msgid="694426978909127287">"Použít starý klient DHCP"</string>
    <string name="mobile_data_always_on" msgid="7745605759775320362">"Mobilní data jsou vždy aktivní"</string>
    <string name="wifi_display_certification_summary" msgid="1155182309166746973">"Zobrazit možnosti certifikace bezdrátového displeje"</string>
    <string name="wifi_verbose_logging_summary" msgid="6615071616111731958">"Zvýšit úroveň protokolování Wi‑Fi zobrazenou v SSID a RSSI při výběru sítě Wi‑Fi."</string>
    <string name="wifi_aggressive_handover_summary" msgid="6328455667642570371">"Pokud je tato možnost zapnuta, bude síť Wi-Fi agresivnější při předávání datového připojení mobilní síti při slabém signálu Wi-Fi."</string>
    <string name="wifi_allow_scan_with_traffic_summary" msgid="2575101424972686310">"Povolí nebo zakáže Wi-Fi roaming na základě množství datového provozu na rozhraní."</string>
    <string name="select_logd_size_title" msgid="7433137108348553508">"Vyrovnávací paměť protokol. nástroje"</string>
    <string name="select_logd_size_dialog_title" msgid="1206769310236476760">"Velikost vyrovnávací paměti protokol. nástroje"</string>
    <string name="select_usb_configuration_title" msgid="2649938511506971843">"Výběr konfigurace USB"</string>
    <string name="select_usb_configuration_dialog_title" msgid="6385564442851599963">"Výběr konfigurace USB"</string>
    <string name="allow_mock_location" msgid="2787962564578664888">"Povolit simulované polohy"</string>
    <string name="allow_mock_location_summary" msgid="317615105156345626">"Povolit simulované polohy"</string>
    <string name="debug_view_attributes" msgid="6485448367803310384">"Kontrola atributu zobrazení"</string>
    <string name="legacy_dhcp_client_summary" msgid="163383566317652040">"Namísto nového klientu DHCP Android použít klient DHCP z verze Lollipop."</string>
    <string name="mobile_data_always_on_summary" msgid="8149773901431697910">"Mobilní data budou vždy ponechána aktivní, i když bude aktivní Wi-Fi (za účelem rychlého přepínání sítí)."</string>
    <string name="adb_warning_title" msgid="6234463310896563253">"Povolit ladění USB?"</string>
    <string name="adb_warning_message" msgid="7316799925425402244">"Ladění prostřednictvím rozhraní USB je určeno pouze pro účely vývoje. Použijte je ke kopírování dat mezi počítačem a zařízením, instalaci aplikací do zařízení bez upozornění a čtení dat protokolů."</string>
    <string name="adb_keys_warning_message" msgid="5659849457135841625">"Zrušit přístup k ladění USB ze všech počítačů, které jste v minulosti autorizovali?"</string>
    <string name="dev_settings_warning_title" msgid="7244607768088540165">"Povolit nastavení pro vývojáře?"</string>
    <string name="dev_settings_warning_message" msgid="2298337781139097964">"Tato nastavení jsou určena pouze pro vývojáře. Mohou způsobit rozbití nebo nesprávné fungování zařízení a nainstalovaných aplikací."</string>
    <string name="verify_apps_over_usb_title" msgid="4177086489869041953">"Ověřit aplikace z USB"</string>
    <string name="verify_apps_over_usb_summary" msgid="9164096969924529200">"Kontrolovat škodlivost aplikací nainstalovaných pomocí nástroje ADB/ADT"</string>
    <string name="enforce_read_external_title" product="nosdcard" msgid="7733257271454664956">"Chránit úložiště USB"</string>
    <string name="enforce_read_external_summary" product="nosdcard" msgid="1798088409346660567">"Aplikace musejí před čtením z úložiště USB žádat o povolení"</string>
    <string name="enforce_read_external_confirm_title" product="nosdcard" msgid="2112813067171502209">"Chránit úložiště USB?"</string>
    <string name="enforce_read_external_confirm_message" product="nosdcard" msgid="605444326545922054">"Pokud je úložiště USB chráněno, musejí aplikace před čtením dat z externího úložiště požádat o povolení.\n\nNěkteré aplikace nemusejí fungovat, dokud je vývojáři neaktualizují."</string>
    <string name="enforce_read_external_title" product="default" msgid="2226662853797940829">"Chránit kartu SD"</string>
    <string name="enforce_read_external_summary" product="default" msgid="2750027486786530064">"Aplikace musejí před čtením z karty SD žádat o povolení"</string>
    <string name="enforce_read_external_confirm_title" product="default" msgid="273220585729800783">"Chránit kartu SD?"</string>
    <string name="enforce_read_external_confirm_message" product="default" msgid="3858482712337574407">"Pokud je karta SD chráněná, musejí aplikace před čtením dat z externího úložiště požádat o povolení.\n\nNěkteré aplikace nemusejí fungovat, dokud je vývojáři neaktualizují."</string>
    <string name="enable_terminal_title" msgid="95572094356054120">"Místní terminál"</string>
    <string name="enable_terminal_summary" msgid="67667852659359206">"Aktivovat terminálovou aplikaci pro místní přístup k prostředí shell"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Zvolte gadget"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Zvolte widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Vytvořit widget a povolit přístup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Po vytvoření widgetu bude moci aplikace <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> získat přístup ke všem datům, které widget zobrazuje."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Vždy povolit aplikaci <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> vytváření widgetů a přístup k jejich datům"</string>
    <string name="battery_history_days" msgid="7110262897769622564">"<xliff:g id="DAYS">%1$d</xliff:g> d <xliff:g id="HOURS">%2$d</xliff:g> h <xliff:g id="MINUTES">%3$d</xliff:g> min <xliff:g id="SECONDS">%4$d</xliff:g> s"</string>
    <string name="battery_history_hours" msgid="7525170329826274999">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> min <xliff:g id="SECONDS">%3$d</xliff:g> s"</string>
    <string name="battery_history_minutes" msgid="1467775596084148610">"<xliff:g id="MINUTES">%1$d</xliff:g> min <xliff:g id="SECONDS">%2$d</xliff:g> s"</string>
    <string name="battery_history_seconds" msgid="4283492130945761685">"<xliff:g id="SECONDS">%1$d</xliff:g> s"</string>
    <string name="battery_history_days_no_seconds" msgid="703063770554334710">"<xliff:g id="DAYS">%1$d</xliff:g> d <xliff:g id="HOURS">%2$d</xliff:g> h <xliff:g id="MINUTES">%3$d</xliff:g> m"</string>
    <string name="battery_history_hours_no_seconds" msgid="663342892615646712">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> m"</string>
    <string name="battery_history_minutes_no_seconds" msgid="7780294302606853082">"<xliff:g id="MINUTES">%1$d</xliff:g> min"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Statistika použití"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Statistika použití"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Řadit podle:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplikace"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Naposledy použito"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Doba použití"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Přístupnost"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Nastavení přístupnosti"</string>
    <string name="accessibility_services_title" msgid="2592221829284342237">"Služby"</string>
    <string name="accessibility_system_title" msgid="7187919089874130484">"Systém"</string>
    <string name="accessibility_display_title" msgid="7610175687949675162">"Obrazovka"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Titulky"</string>
    <string name="accessibility_screen_magnification_title" msgid="7001782548715744981">"Gesta pro přiblížení"</string>
    <string name="accessibility_screen_magnification_summary" msgid="1178289000423776584">"Je-li tato funkce zapnutá, můžete zobrazení přibližovat a oddalovat tak, že třikrát klepnete na obrazovku.\n\nPři přiblížení můžete provádět tyto činnosti:\n"<ul><li>"Posunutí: táhněte po obrazovce minimálně dvěma prsty."</li>\n<li>"Změna úrovně přiblížení: alespoň dva prsty stáhněte k sobě, nebo roztáhněte od sebe."</li></ul>\n\n"Také je možné dočasně zvětšit oblast pod prstem. Stačí na ni třikrát klepnout a podržet ji. V takto zvětšeném náhledu můžete přetáhnutím prstu prohlížet libovolné části obrazovky. Do předchozího zobrazení se vrátíte zdvihnutím prstu.\n\nPoznámka: Zvětšení trojitým klepnutím funguje ve všech částech obrazovky s výjimkou klávesnice a navigační lišty."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="6752037184140789970">"Zkratka přístupnosti"</string>
    <string name="accessibility_global_gesture_preference_summary_on" msgid="6180927399052022181">"Zapnuto"</string>
    <string name="accessibility_global_gesture_preference_summary_off" msgid="8102103337813609849">"Vypnuto"</string>
    <string name="accessibility_global_gesture_preference_description" msgid="750438015254396963">"Je-li tato funkce zapnutá, můžete rychle ve dvou krocích aktivovat funkce přístupnosti:\n\n1. Stiskněte vypínač a držte jej, dokud neuslyšíte zvuk nebo neucítíte vibraci.\n\n2. Přidržte obrazovku dvěma prsty, dokud neuslyšíte potvrzovací zvuk.\n\nMá-li zařízení více uživatelů, pomocí této zkratky lze na uzamčené obrazovce dočasně aktivovat funkce přístupnosti, dokud zařízení nebude odemčeno."</string>
    <string name="accessibility_toggle_large_text_preference_title" msgid="6307247527580207161">"Velký text"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Text s vysokým kontrastem"</string>
    <string name="accessibility_toggle_screen_magnification_preference_title" msgid="2472285215737820469">"Přiblížení obrazovky"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Automaticky aktualizovat přiblížení"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Aktual. přiblížení obrazovky při přepnutí aplikací"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Vypínač ukončí hovor"</string>
    <string name="accessibility_toggle_speak_password_preference_title" msgid="5986628515113204844">"Vyslovovat hesla"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Prodleva přidržení"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Převrácení barev"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="8658240868230680912">"(Experimentální) Může mít vliv na výkon"</string>
    <string name="accessibility_display_daltonizer_preference_title" msgid="5800761362678707872">"Korekce barev"</string>
    <string name="accessibility_display_daltonizer_preference_subtitle" msgid="3484969015295282911">"Funkce je experimentální a může mít vliv na výkon."</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Zobrazit v rychlém nastavení"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Režim korekce"</string>
    <string name="daltonizer_type_overridden" msgid="3116947244410245916">"Přepsáno nastavením <xliff:g id="TITLE">%1$s</xliff:g>"</string>
    <string name="daltonizer_mode_disabled" msgid="7482661936053801862">"Vypnuto"</string>
    <string name="daltonizer_mode_monochromacy" msgid="8485709880666106721">"Monochromázie"</string>
    <string name="daltonizer_mode_deuteranomaly" msgid="5475532989673586329">"Deuteranomálie (červená a zelená)"</string>
    <string name="daltonizer_mode_protanomaly" msgid="8424148009038666065">"Protanomálie (červená a zelená)"</string>
    <string name="daltonizer_mode_tritanomaly" msgid="481725854987912389">"Tritanomálie (modrá a žlutá)"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Nastavení"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Zapnuto"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Vypnuto"</string>
    <string name="accessibility_feature_or_input_method_not_allowed" msgid="5950315477009501647">"Není povoleno vaší organizací"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Náhled"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Standardní možnosti"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Jazyk"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Velikost textu"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Styl titulků"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Vlastní možnosti"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Barva pozadí"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Neprůhlednost pozadí"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Barva okna titulků"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Neprůhlednost okna titulků"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Barva textu"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Neprůhlednost textu"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Barva okraje"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Typ okraje"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Rodina písem"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Titulky budou vypadat takto"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Výchozí"</string>
    <string name="color_title" msgid="4258931051732243983">"Barva"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"Výchozí"</string>
    <string name="color_none" msgid="3475640044925814795">"Žádná"</string>
    <string name="color_white" msgid="8045195170201590239">"Bílá"</string>
    <string name="color_gray" msgid="9192312087142726313">"Šedá"</string>
    <string name="color_black" msgid="7517353520909872561">"Černá"</string>
    <string name="color_red" msgid="4949354900304125428">"Červená"</string>
    <string name="color_green" msgid="5537717328428845841">"Zelená"</string>
    <string name="color_blue" msgid="7731984529016953223">"Modrá"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Tyrkysová"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Žlutá"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Purpurová"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Zapnout <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"<xliff:g id="SERVICE">%1$s</xliff:g> potřebuje:"</string>
    <string name="touch_filtered_warning" msgid="8644034725268915030">"Žádost o oprávnění je blokována jinou aplikací. Nastavení proto vaši odpověď nemůže ověřit."</string>
    <string name="enable_service_encryption_warning" msgid="3064686622453974606">"Pokud zapnete službu <xliff:g id="SERVICE">%1$s</xliff:g>, zařízení nebude používat zámek obrazovky k vylepšení šifrování dat."</string>
    <string name="secure_lock_encryption_warning" msgid="460911459695077779">"Vzhledem k tomu, že jste zapnuli službu přístupnosti, nebude zařízení používat zámek obrazovky k vylepšení šifrování dat."</string>
    <string name="enable_service_pattern_reason" msgid="777577618063306751">"Protože zapnutí služby <xliff:g id="SERVICE">%1$s</xliff:g> má vliv na šifrování dat, je třeba, abyste potvrdili své gesto."</string>
    <string name="enable_service_pin_reason" msgid="7882035264853248228">"Protože zapnutí služby <xliff:g id="SERVICE">%1$s</xliff:g> má vliv na šifrování dat, je třeba, abyste potvrdili svůj kód PIN."</string>
    <string name="enable_service_password_reason" msgid="1224075277603097951">"Protože zapnutí služby <xliff:g id="SERVICE">%1$s</xliff:g> má vliv na šifrování dat, je třeba, abyste potvrdili své heslo."</string>
    <string name="capability_title_receiveAccessibilityEvents" msgid="1869032063969970755">"Sledovat vaše akce"</string>
    <string name="capability_desc_receiveAccessibilityEvents" msgid="6640333613848713883">"Při používání aplikací vás budeme informovat o provedených akcích."</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Vypnout funkci <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="2012273739481042318">"Klepnutím na tlačítko OK funkci <xliff:g id="SERVICE">%1$s</xliff:g> deaktivujete."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Žádná služba není nainstalována"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"K dispozici není žádný popis."</string>
    <string name="settings_button" msgid="3006713718908152930">"Nastavení"</string>
    <string name="print_settings" msgid="4742428530112487843">"Tisk"</string>
    <string name="print_settings_title" msgid="3685449667822217816">"Tiskové služby"</string>
    <string name="print_service_security_warning_title" msgid="2338435517408144841">"Chcete používat službu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="print_service_security_warning_summary" msgid="7567131958613064363">"Dokument může cestou do tiskárny projít jedním i více servery."</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Žádná služba není nainstalována"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Nebyly nalezeny žádné tiskárny"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Nastavení"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Přidat tiskárny"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Zapnuto"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Vypnuto"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Přidat službu"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Přidat tiskárnu"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Vyhledávání"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Vyhledávání tiskáren"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Služba je vypnuta"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Tiskové úlohy"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Tisková úloha"</string>
    <string name="print_restart" msgid="8373999687329384202">"Restartovat"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Storno"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Tisk úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Rušení úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Chyba tiskárny u úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Tiskárna blokuje úlohu <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Vyhledávací pole se zobrazuje"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Vyhledávací pole je skryto"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Baterie"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Co využívá baterii"</string>
    <string name="power_usage_not_available" msgid="3109326074656512387">"Údaje o spotřebě nejsou známy."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"Zbývá <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do nabití"</string>
    <string name="power_discharging_duration" msgid="1605929174734600590">"<xliff:g id="LEVEL">%1$s</xliff:g> – zbývá přibližně <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="power_charging" msgid="1779532561355864267">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATE">%2$s</xliff:g>"</string>
    <string name="power_charging_duration" msgid="2853265177761520490">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="TIME">%2$s</xliff:g> do úplného nabití"</string>
    <string name="power_charging_duration_ac" msgid="3969186192576594254">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="TIME">%2$s</xliff:g> do úplného nabití ze zásuvky"</string>
    <string name="power_charging_duration_usb" msgid="182405645340976546">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="TIME">%2$s</xliff:g> do úplného nabití přes USB"</string>
    <string name="power_charging_duration_wireless" msgid="1829295708243159464">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="TIME">%2$s</xliff:g> do úplného nabití bezdrátově"</string>
    <string name="power_usage_list_summary" msgid="2409288197839512482">"Použití od posledního úplného nabití"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Využití baterie od odpojení"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Využití baterie od obnovení"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"Provoz na baterii: <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 odpojení"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Nabíjení"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Zapnutá obrazovka"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"Zapnutá GPS"</string>
    <string name="battery_stats_camera_on_label" msgid="4935637383628414968">"Fotoaparát je zapnutý"</string>
    <string name="battery_stats_flashlight_on_label" msgid="4319637669889411307">"Svítilna je zapnutá"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Aktivní režim"</string>
    <string name="battery_stats_phone_signal_label" msgid="3537569115723850618">"Signál mobilní sítě"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Doba provozu zařízení"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Doba provozu Wi-Fi"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Doba provozu modulu Wi-Fi"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Podrobnosti historie"</string>
    <string name="details_title" msgid="3792801565213935385">"Podr. využívání"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Podrobnosti využívání"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Upravit spotřebu energie"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Zahrnuté balíčky"</string>
    <string name="power_screen" msgid="3023346080675904613">"Displej"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Svítilna"</string>
    <string name="power_camera" msgid="4976286950934622605">"Fotoaparát"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="6596471490976003056">"Pohotovostní režim"</string>
    <string name="power_phone" msgid="5392641106474567277">"Hlasové hovory"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tablet v nečinnosti"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"V nečinnosti"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Různé"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Nadhodnoceno"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"Doba provozu procesoru"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"CPU v popředí"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Zakázat režim spánku"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Wi-Fi je aktivní"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tablet"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefon"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Odeslané pakety – mobilní síť"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Přijaté pakety – mobilní síť"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Modul GSM je aktivní"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Odeslané pakety – Wi‑Fi"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Přijaté pakety – Wi‑Fi"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Zvuk"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Video"</string>
    <string name="usage_type_camera" msgid="8299433109956769757">"Fotoaparát"</string>
    <string name="usage_type_flashlight" msgid="1516392356962208230">"Svítilna"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Doba zapnutí"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Doba bez signálu"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Celková kapacita baterie"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Vypočtená spotřeba energie"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Skutečná spotřeba energie"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Vynutit ukončení"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Informace o aplikaci"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Nastavení aplikace"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Nastavení obrazovky"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Nastavení Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Nastavení Bluetooth"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Využití baterie hlasovými hovory"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Využití baterie v pohotovostním režimu tabletu"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Využití baterie v pohotovostním režimu telefonu"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Využití baterie jednotkou GSM"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"V oblastech bez pokrytí přepněte do režimu Letadlo"</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Využití baterie svítilnou"</string>
    <string name="battery_desc_camera" msgid="7375389919760613499">"Využití baterie fotoaparátem"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Využití baterie displejem a podsvícením"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Snižte jas displeje nebo interval jeho vypínání"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Využití baterie modulem Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="7776093125855397043">"Pokud síť Wi-Fi nepoužíváte nebo na daném místě není k dispozici, vypněte modul Wi-Fi."</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Využití baterie technologií Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="4565141162650835009">"Vypněte funkci Bluetooth, když ji nepoužíváte."</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Zkuste se připojit k jinému zařízení Bluetooth"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Využití baterie aplikací"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Ukončete aplikaci nebo ji odinstalujte"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Vyberte režim spořiče baterie"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"V aplikaci mohou být k dispozici nastavení ke snížení spotřeby"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Baterie spotřebovaná uživatelem"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Různé využití energie"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"Informace o využití baterie jsou přibližné odhady a neobsahují všechny způsoby využití energie. Pod označením „Různé využití energie“ uvádíme rozdíl mezi vypočtenou přibližnou spotřebou energie a skutečnou spotřebou zjištěnou podle baterie."</string>
    <string name="battery_desc_overcounted" msgid="5481865509489228603">"Nadhodnocení spotřeby energie"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> od odpojení"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Při posledním odpojení pro <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Využití baterie celkem"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Aktualizovat"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"OS Android"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Mediaserver"</string>
    <string name="process_dex2oat_label" msgid="2592408651060518226">"Optimalizace aplikací"</string>
    <string name="battery_saver" msgid="1426682272004907982">"Spořič baterie"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Zapnout automaticky"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Nikdy"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="7536784431655058267">"%1$s baterie"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Statistiky procesů"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Podrobné statistiky běžících procesů"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Využití paměti"</string>
    <string name="process_stats_total_duration" msgid="7417201400853728029">"Za poslední období <xliff:g id="TIMEDURATION">%3$s</xliff:g> bylo využito <xliff:g id="USEDRAM">%1$s</xliff:g> z <xliff:g id="TOTALRAM">%2$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="6522457033380025618">"Za dobu <xliff:g id="TIMEDURATION">%2$s</xliff:g> bylo použito <xliff:g id="PERCENT">%1$s</xliff:g> paměti RAM"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"na pozadí"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"v popředí"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"v mezipaměti"</string>
    <string name="process_stats_os_label" msgid="4813434110442733392">"OS Android"</string>
    <string name="process_stats_os_native" msgid="5322428494231768472">"Nativní"</string>
    <string name="process_stats_os_kernel" msgid="1938523592369780924">"Jádro"</string>
    <string name="process_stats_os_zram" msgid="677138324651671575">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="6432533624875078233">"Mezipaměti"</string>
    <string name="process_stats_ram_use" msgid="976912589127397307">"Využití RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="5398191511030462404">"Využití RAM (pozadí)"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Doba běhu"</string>
    <string name="processes_subtitle" msgid="6827502409379462438">"Procesy"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Služby"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Doba trvání"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Podrobnosti o paměti"</string>
    <string name="mem_state_subtitle" msgid="2407238869781011933">"Stavy paměti"</string>
    <string name="mem_use_subtitle" msgid="7319468770222422412">"Využití paměti"</string>
    <string name="mem_use_kernel_type" msgid="8698327165935012484">"Jádro"</string>
    <string name="mem_use_native_type" msgid="5976704902328347400">"Nativní"</string>
    <string name="mem_use_kernel_cache_type" msgid="6411475064463957513">"Mezipaměti jádra"</string>
    <string name="mem_use_zram_type" msgid="9087217476795358232">"Odkládací prostor zRam"</string>
    <string name="mem_use_free_type" msgid="717708548454880840">"Volná"</string>
    <string name="mem_use_total" msgid="6308786055749777934">"Celkem"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 hodiny"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 hodin"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 hodin"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 den"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Zobrazit systémové aplikace"</string>
    <string name="menu_hide_system" msgid="4106826741703745733">"Skrýt systémové aplikace"</string>
    <string name="menu_show_percentage" msgid="4717204046118199806">"Zobrazit procenta"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Použít USS"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Typ statistik"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"Pozadí"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"Na popředí"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"V mezipaměti"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Hlasový vstup a výstup"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Nastavení hlasového vstupu a výstupu"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Hlasové vyhledávání"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Klávesnice Android"</string>
    <string name="voice_category" msgid="1430370497125803904">"Řeč"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Nastavení hlasového zadávání"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Hlasové zadávání"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Služby hlasového zadávání"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Úplná aktivace klíčových slov a interakce"</string>
    <string name="voice_recognizer_preference_summary" msgid="669880813593690527">"Jednoduchý převod řeči na text"</string>
    <string name="voice_interaction_security_warning" msgid="6378608263983737325">"Služba hlasového zadávání bude moci neustále monitorovat hlas a ovládat za vás aplikace s aktivovaným hlasovým zadáváním. Služba pochází z <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Chcete použití této služby povolit?"</string>
    <string name="tts_settings" msgid="8186971894801348327">"Nastavení převodu textu na řeč"</string>
    <string name="tts_settings_title" msgid="1237820681016639683">"Převod textu na řeč"</string>
    <string name="use_default_tts_settings_title" msgid="1577063839539732930">"Vždy používat moje nastavení"</string>
    <string name="use_default_tts_settings_summary" msgid="5916421806783703823">"Výchozí nastavení níže přepíše nastavení jednotlivých aplikací"</string>
    <string name="tts_default_settings_section" msgid="5787915620218907443">"Výchozí nastavení"</string>
    <string name="tts_default_synth_title" msgid="4755558388333117572">"Výchozí modul"</string>
    <string name="tts_default_synth_summary" msgid="7326298606388069173">"Nastavit modul syntézy řeči, který se bude používat pro mluvený text"</string>
    <string name="tts_default_rate_title" msgid="6030550998379310088">"Rychlost řeči"</string>
    <string name="tts_default_rate_summary" msgid="4061815292287182801">"Rychlost mluveného textu"</string>
    <string name="tts_default_pitch_title" msgid="6135942113172488671">"Výška"</string>
    <string name="tts_default_pitch_summary" msgid="1328298665182885277">"Určuje rejstřík mluveného textu"</string>
    <string name="tts_default_lang_title" msgid="8018087612299820556">"Jazyk"</string>
    <string name="tts_lang_use_system" msgid="2679252467416513208">"Použít jazyk systému"</string>
    <string name="tts_lang_not_selected" msgid="7395787019276734765">"Nebyl vybrán jazyk"</string>
    <string name="tts_default_lang_summary" msgid="5219362163902707785">"Nastavení jazyka hlasu pro mluvený text"</string>
    <string name="tts_play_example_title" msgid="7094780383253097230">"Poslechnout příklad"</string>
    <string name="tts_play_example_summary" msgid="8029071615047894486">"Přehrát krátkou ukázku syntézy řeči"</string>
    <string name="tts_install_data_title" msgid="4264378440508149986">"Nainstalovat hlasová data"</string>
    <string name="tts_install_data_summary" msgid="5742135732511822589">"Nainstalovat hlasová data pro syntézu řeči"</string>
    <string name="tts_data_installed_summary" msgid="9162111552859972809">"Hlas pro syntézu řeči je již řádně nainstalován."</string>
    <string name="tts_settings_changed_demo" msgid="4926518555912328645">"Nastavení se změnilo. Toto je příklad současného znění."</string>
    <string name="tts_engine_error" msgid="6336134545728152761">"Modul, který jste vybrali, nelze spustit."</string>
    <string name="tts_engine_error_config" msgid="5820525416624637313">"Konfigurovat"</string>
    <string name="tts_engine_error_reselect" msgid="2415399149293842112">"Vyberte jiný modul"</string>
    <string name="tts_engine_security_warning" msgid="8786238102020223650">"Modul pro syntézu řeči může shromažďovat veškerý mluvený text, včetně osobních dat jako jsou hesla nebo čísla kreditních karet. Je založen na modulu <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>. Chcete modul pro syntézu řeči aktivovat?"</string>
    <string name="tts_engine_network_required" msgid="1190837151485314743">"Pro tento jazyk je k převodu textu na hlasový výstup potřeba připojení k síti."</string>
    <string name="tts_default_sample_string" msgid="4040835213373086322">"Toto je příklad syntézy řeči"</string>
    <string name="tts_status_title" msgid="7268566550242584413">"Stav výchozího jazyka"</string>
    <string name="tts_status_ok" msgid="1309762510278029765">"Jazyk <xliff:g id="LOCALE">%1$s</xliff:g> je plně podporován"</string>
    <string name="tts_status_requires_network" msgid="6042500821503226892">"Jazyk <xliff:g id="LOCALE">%1$s</xliff:g> vyžaduje připojení k síti"</string>
    <string name="tts_status_not_supported" msgid="4491154212762472495">"Jazyk <xliff:g id="LOCALE">%1$s</xliff:g> není podporován"</string>
    <string name="tts_status_checking" msgid="4983413982985913047">"Probíhá kontrola..."</string>
    <string name="tts_engines_section" msgid="7515470972378742429">"Moduly"</string>
    <string name="tts_engine_name_settings" msgid="4974538563074395920">"Nastavení modulu <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="tts_engine_name_is_enabled_summary" msgid="4909484006804022115">"Položka <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> je aktivována"</string>
    <string name="tts_engine_name_is_disabled_summary" msgid="7644198182255168200">"Možnost <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> je deaktivována"</string>
    <string name="tts_engine_settings_section" msgid="2346105138448751893">"Nastavení modulu"</string>
    <string name="tts_engine_settings_title" msgid="3499112142425680334">"<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">"Nainstalováno"</string>
    <string name="pico_not_installed" msgid="6266845418419994311">"Není nainstalováno"</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">"Nainstalován modul syntézy řeči"</string>
    <string name="tts_notif_engine_install_message" msgid="7250804349781973329">"Před použitím modul povolte."</string>
    <string name="tts_engine_settings_button" msgid="1030512042040722285">"Spustit vyhledávač"</string>
    <string name="tts_engine_preference_section_title" msgid="448294500990971413">"Preferovaný modul"</string>
    <string name="tts_general_section_title" msgid="4402572014604490502">"Obecné"</string>
    <string name="gadget_title" msgid="5519037532720577836">"Kontrola spotřeby energie"</string>
    <string name="gadget_toggle_wifi" msgid="319262861956544493">"Probíhá aktualizace nastavení Wi-Fi"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Probíhá aktualizace nastavení Bluetooth"</string>
    <string name="gadget_state_template" msgid="5156935629902649932">"<xliff:g id="ID_1">%1$s</xliff:g> <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="gadget_state_on" msgid="6909119593004937688">"zapnuto"</string>
    <string name="gadget_state_off" msgid="5220212352953066317">"vypnuto"</string>
    <string name="gadget_state_turning_on" msgid="3395992057029439039">"zapínání"</string>
    <string name="gadget_state_turning_off" msgid="2395546048102176157">"vypínání"</string>
    <string name="gadget_wifi" msgid="4712584536500629417">"Wi-Fi"</string>
    <string name="gadget_bluetooth" msgid="8998572807378694410">"Bluetooth"</string>
    <string name="gadget_location" msgid="2974757497945178165">"Poloha"</string>
    <string name="gadget_sync" msgid="858895763714222152">"Synchronizace"</string>
    <string name="gadget_brightness_template" msgid="930541920933123603">"Jas <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="gadget_brightness_state_auto" msgid="6667967252426515446">"automaticky"</string>
    <string name="gadget_brightness_state_full" msgid="6814570109772137631">"úplný"</string>
    <string name="gadget_brightness_state_half" msgid="3696671957608774204">"poloviční"</string>
    <string name="gadget_brightness_state_off" msgid="946382262872753084">"vypnuto"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"Síť VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Úložiště pověření"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Instalovat z úložiště"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Instalace z karty SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Nainstalovat certifikáty z úložiště"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Nainstalovat certifikáty z karty SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Vymazat pověření"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Odstranit všechny certifikáty"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Důvěryhodná pověření"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Zobrazit důvěryhodné certifikáty CA"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Rozšířené nastavení"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Typ úložiště"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Hardwarové"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Pouze software"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Pro tohoto uživatele jsou identifikační údaje nedostupné."</string>
    <string name="credentials_unlock" msgid="385427939577366499"></string>
    <string name="credentials_unlock_hint" msgid="2301301378040499348">"Zadejte heslo pro úložiště pověření."</string>
    <string name="credentials_old_password" msgid="7553393815538684028">"Aktuální heslo:"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Odstranit veškerý obsah?"</string>
    <string name="credentials_password_too_short" msgid="7502749986405522663">"Heslo musí mít alespoň 8 znaků."</string>
    <string name="credentials_wrong_password" msgid="2541932597104054807">"Nesprávné heslo."</string>
    <string name="credentials_reset_warning" msgid="5320653011511797600">"Nesprávné heslo. Zbývá vám jeden pokus, než bude úložiště pověření smazáno."</string>
    <string name="credentials_reset_warning_plural" msgid="6514085665301095279">"Nesprávné heslo. Počet zbývajících pokusů, než bude úložiště pověření smazáno: <xliff:g id="NUMBER">%1$d</xliff:g>"</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Úložiště pověření je vymazáno."</string>
    <string name="credentials_not_erased" msgid="7685932772284216097">"Úložiště pověření nelze smazat."</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Úložiště pověření je aktivováno."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="6757119179588664966">"Před použitím úložiště pověření musíte nastavit kód PIN nebo heslo zámku obrazovky."</string>
    <string name="usage_access_title" msgid="332333405495457839">"Přístup k datům o používání"</string>
    <string name="emergency_tone_title" msgid="1055954530111587114">"Tísňové vyzvánění"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Nastavit chování při tísňovém volání"</string>
    <string name="privacy_settings" msgid="5446972770562918934">"Záloha a obnova dat"</string>
    <string name="privacy_settings_title" msgid="4856282165773594890">"Záloha a obnova dat"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Zálohování a obnovení"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Osobní údaje"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Zálohování mých dat"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Zálohovat data aplikací, hesla sítí Wi-Fi a další nastavení na serverech Google"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Záložní účet"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Zahrnout data aplikací"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Automatické obnovení"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Při přeinstalaci aplikace obnovit zálohovaná nastavení a další data"</string>
    <string name="backup_inactive_title" msgid="5355557151569037197">"Služba zálohování není aktivní."</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Aktuálně nejsou zálohovaná data ukládána do žádného účtu."</string>
    <string name="local_backup_password_title" msgid="3860471654439418822">"Heslo pro zálohy v počítači"</string>
    <string name="local_backup_password_summary_none" msgid="6951095485537767956">"Úplné zálohy v počítači nejsou v současné době chráněny"</string>
    <string name="local_backup_password_summary_change" msgid="2731163425081172638">"Tuto možnost vyberte, chcete-li změnit nebo odebrat heslo pro úplné zálohy v počítači"</string>
    <string name="local_backup_password_toast_success" msgid="582016086228434290">"Nové heslo pro zálohy je nastaveno"</string>
    <string name="local_backup_password_toast_confirmation_mismatch" msgid="7805892532752708288">"Nové heslo se neshoduje s potvrzením hesla."</string>
    <string name="local_backup_password_toast_validation_failure" msgid="5646377234895626531">"Nastavení hesla pro zálohy selhalo"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Chcete přestat zálohovat hesla sítí Wi-Fi, záložky, další nastavení, data aplikací a vymazat všechny kopie ze serverů Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="694766389396659626">"Zastavit zálohování dat zařízení (jako jsou hesla sítí Wi-Fi a historie volání) a dat aplikací (jako jsou nastavení a soubory uložené aplikacemi) a vymazat všechny kopie na vzdálených serverech?"</string>
    <string name="fullbackup_data_summary" msgid="960850365007767734">"Automaticky vzdáleně zálohujte data zařízení (jako jsou hesla sítí Wi-Fi a historie volání) a data aplikací (jako jsou nastavení a soubory uložené aplikacemi).\n\nKdyž zapnete automatické zálohování, data zařízení a aplikací se budou pravidelně ukládat do vzdáleného úložiště. Data aplikací mohou zahrnovat data, která uložila aplikace (v závislosti na nastavení vývojáře), včetně potenciálně citlivých dat, jako jsou kontakty, zprávy a fotky."</string>
    <string name="device_admin_settings_title" msgid="1335557832906433309">"Nastavení správce zařízení"</string>
    <string name="active_device_admin_msg" msgid="6930903262612422111">"Správce zařízení"</string>
    <string name="remove_device_admin" msgid="3596845261596451437">"Deaktivovat"</string>
    <string name="select_device_admin_msg" msgid="2645509057946368094">"Správci zařízení"</string>
    <string name="no_device_admins" msgid="702695100241728775">"Není k dispozici žádný správce zařízení"</string>
    <string name="managed_profile_device_admin_info" msgid="5048846624960067582">"Chcete-li aplikaci <xliff:g id="APP_NAME">%1$s</xliff:g> zakázat přístup k pracovnímu profilu, odstraňte jej v sekci Nastavení &gt; Účty."</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Osobní"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Pracovní"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Nejsou k dispozici žádní zástupci důvěryhodnosti."</string>
    <string name="add_device_admin_msg" msgid="6246742476064507965">"Aktivovat správce zařízení?"</string>
    <string name="add_device_admin" msgid="7133327675884827091">"Aktivovat"</string>
    <string name="device_admin_add_title" msgid="7705551449705676363">"Správce zařízení"</string>
    <string name="device_admin_warning" msgid="2026747446313628233">"Aktivací tohoto správce umožníte aplikaci <xliff:g id="APP_NAME">%1$s</xliff:g> provádět následující operace:"</string>
    <string name="device_admin_status" msgid="4252975713178851910">"Správce je aktivní a umožňuje aplikaci <xliff:g id="APP_NAME">%1$s</xliff:g> provádět následující operace:"</string>
    <string name="profile_owner_add_title" msgid="6249331160676175009">"Aktivovat správce profilů?"</string>
    <string name="adding_profile_owner_warning" msgid="8081841501073689534">"Budete-li pokračovat, uživatele bude spravovat váš administrátor, který může ukládat vaše osobní data i jiná související data.\n\nAdministrátor může sledovat a spravovat nastavení, přístup, aplikace a data přidružená k tomuto uživateli, včetně aktivity v síti a informací o poloze vašeho zařízení."</string>
    <string name="untitled_apn" msgid="1230060359198685513">"Bez názvu"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Obecné"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Protokol oznámení"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Tón vyzvánění a vibrace"</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"Systém"</string>
    <string name="wifi_setup_title" msgid="2970260757780025029">"Nastavení připojení k síti Wi-Fi"</string>
    <string name="wifi_setup_title_editing_network" msgid="6020614644556717979">"Připojení k síti Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_connecting_network" msgid="5572226790101017822">"Připojování k síti Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>…"</string>
    <string name="wifi_setup_title_connected_network" msgid="1608788657122010919">"Připojeno k síti Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Přidat síť"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Nepřipojeno"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Přidat síť"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Aktualizovat seznam"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Přeskočit"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"Další"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Zpět"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Podrobnosti sítě"</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Připojit"</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Odstranit"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Uložit"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Zrušit"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Vyhledávání sítí..."</string>
    <string name="wifi_setup_status_select_network" msgid="7519563569903137003">"K síti se připojíte tak, že se jí dotknete"</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Připojit k existující síti"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Připojit k nezabezpečené síti"</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Zadejte konfiguraci sítě"</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Připojit k nové síti"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Připojování…"</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Přejít k dalšímu kroku"</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="6796317704783144190">"Protokol EAP není podporován."</string>
    <string name="wifi_setup_eap_not_supported" msgid="6812710317883658843">"Připojení Wi-Fi EAP nelze nakonfigurovat při instalaci. Můžete to provést po dokončení instalace v části Nastavení &gt; Bezdrátová připojení a sítě."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"Připojování může trvat několik minut..."</string>
    <string name="wifi_setup_description_connected" msgid="736032046548460779">"Chcete-li pokračovat v nastavení, klepněte na "<b>"Další"</b>".\n\nChcete-li se připojit k jiné síti Wi-Fi, klepněte na "<b>"Zpět"</b>"."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Synchronizace zapnuta"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Synchronizace deaktivována"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Probíhá synchronizace..."</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Chyba synchronizace."</string>
    <string name="sync_failed" msgid="1696499856374109647">"Synchronizace se nezdařila"</string>
    <string name="sync_active" msgid="8476943765960863040">"Synchronizace je aktivní"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Synchronizace"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Nastaly potíže se synchronizací. Služba bude brzy obnovena."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Přidat účet"</string>
    <string name="managed_profile_not_available_label" msgid="852263300911325904">"Pracovní profil zatím není k dispozici"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Odstranit pracovní profil"</string>
    <string name="background_data" msgid="5779592891375473817">"Data na pozadí"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Aplikace mohou kdykoli synchronizovat, odesílat a přijímat data."</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Deaktivovat data na pozadí?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Deaktivace přenosu dat na pozadí šetří baterii a snižuje objem přenesených dat. Některé aplikace mohou přesto datové připojení na pozadí používat."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Autom. synch. data aplikací"</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Synchronizace je zapnuta"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Synchronizace vypnuta"</string>
    <string name="sync_error" msgid="5060969083117872149">"Chyba synchronizace"</string>
    <string name="last_synced" msgid="4242919465367022234">"Poslední synchronizace <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Probíhá synchronizace..."</string>
    <string name="settings_backup" msgid="2274732978260797031">"Nastavení zálohování"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Zálohovat moje nastavení"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Synchronizovat"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Zrušit synchronizaci"</string>
    <string name="sync_one_time_sync" msgid="6766593624598183090">"Synchronizaci provedete dotykem<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ář"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Kontakty"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Vítá vás aplikace Google Sync."</font>" \nNový pohled společnosti Google na synchronizaci dat vám poskytuje přístup ke kontaktům, schůzkám a dalším informacím, ať jste kdekoli."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Nastavení synchronizace aplikací"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Data a synchronizace"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Změnit heslo"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Nastavení účtu"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Odebrat účet"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Přidat účet"</string>
    <string name="finish_button_label" msgid="481587707657751116">"Dokončit"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Chcete odebrat účet?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Odebráním účtu smažete z tabletu také všechny zprávy, kontakty a další data tohoto účtu."</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Odebráním účtu smažete z telefonu také všechny zprávy, kontakty a další data tohoto účtu."</string>
    <string name="remove_account_failed" msgid="6980737964448187854">"Administrátor tuto změnu zakázal"</string>
    <string name="provider_label" msgid="7724593781904508866">"Zobrazit odběry"</string>
    <!-- no translation found for sync_item_title (4782834606909853006) -->
    <skip />
    <string name="cant_sync_dialog_title" msgid="2777238588398046285">"Nelze ručně synchronizovat"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Synchronizace této položky je aktuálně deaktivována. Chcete-li nastavení změnit, dočasně zapněte přenos dat na pozadí a automatickou synchronizaci."</string>
    <string name="wimax_settings" msgid="2655139497028469039">"4G"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"Adresa MAC sítě 4G"</string>
    <string name="enter_password" msgid="8035706727471334122">"Chcete-li spustit Android, zadejte heslo"</string>
    <string name="enter_pin" msgid="5305333588093263790">"Chcete-li spustit Android, zadejte PIN"</string>
    <string name="enter_pattern" msgid="4187435713036808566">"Chcete-li spustit Android, nakreslete gesto"</string>
    <string name="cryptkeeper_wrong_pattern" msgid="8423835922362956999">"Nesprávné gesto"</string>
    <string name="cryptkeeper_wrong_password" msgid="5200857195368904047">"Nesprávné heslo"</string>
    <string name="cryptkeeper_wrong_pin" msgid="755720788765259382">"Nesprávný kód PIN"</string>
    <string name="checking_decryption" msgid="8287458611802609493">"Kontrola…"</string>
    <string name="starting_android" msgid="4001324195902252681">"Spouštění systému Android…"</string>
    <string name="delete" msgid="4219243412325163003">"Smazat"</string>
    <string name="misc_files" msgid="6720680815969643497">"Různé soubory"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"vybráno: <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">"Vybrat vše"</string>
    <string name="hdcp_checking_title" msgid="8605478913544273282">"Kontrola HDCP"</string>
    <string name="hdcp_checking_dialog_title" msgid="5141305530923283">"Nastavit chování kontroly HDCP"</string>
    <string name="debug_debugging_category" msgid="6781250159513471316">"Ladění"</string>
    <string name="debug_app" msgid="8349591734751384446">"Vybrat aplikaci pro ladění"</string>
    <string name="debug_app_not_set" msgid="718752499586403499">"Není nastavena žádná aplikace pro ladění"</string>
    <string name="debug_app_set" msgid="2063077997870280017">"Aplikace pro ladění: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="select_application" msgid="5156029161289091703">"Výběr aplikace"</string>
    <string name="no_application" msgid="2813387563129153880">"Nic"</string>
    <string name="wait_for_debugger" msgid="1202370874528893091">"Počkat na ladicí program"</string>
    <string name="wait_for_debugger_summary" msgid="1766918303462746804">"Aplikace čeká na připojení ladicího programu"</string>
    <string name="debug_input_category" msgid="1811069939601180246">"Vstup"</string>
    <string name="debug_drawing_category" msgid="6755716469267367852">"Vykreslování"</string>
    <string name="debug_hw_drawing_category" msgid="6220174216912308658">"Hardwarově urychlené vykreslování"</string>
    <string name="media_category" msgid="4388305075496848353">"Média"</string>
    <string name="debug_monitoring_category" msgid="7640508148375798343">"Sledování"</string>
    <string name="strict_mode" msgid="1938795874357830695">"Přísný režim aktivován"</string>
    <string name="strict_mode_summary" msgid="142834318897332338">"Rozblikat obrazovku při dlouhých operacích hlavního vlákna"</string>
    <string name="pointer_location" msgid="6084434787496938001">"Umístění ukazatele"</string>
    <string name="pointer_location_summary" msgid="840819275172753713">"Zobrazit překryvnou vrstvu s aktuálními daty o dotycích"</string>
    <string name="show_touches" msgid="1356420386500834339">"Zobrazit dotyky"</string>
    <string name="show_touches_summary" msgid="6684407913145150041">"Zobrazit vizuální zpětnou vazbu pro dotyky"</string>
    <string name="show_screen_updates" msgid="5470814345876056420">"Zobrazit obnovení obsahu"</string>
    <string name="show_screen_updates_summary" msgid="2569622766672785529">"Rozblikat obsah okna při aktualizaci"</string>
    <string name="show_hw_screen_updates" msgid="5036904558145941590">"Zobrazit obnovení s GPU"</string>
    <string name="show_hw_screen_updates_summary" msgid="1115593565980196197">"Rozblikat zobrazení v oknech při vykreslování pomocí GPU"</string>
    <string name="show_hw_layers_updates" msgid="5645728765605699821">"Zobrazit aktual. HW vrstev"</string>
    <string name="show_hw_layers_updates_summary" msgid="5296917233236661465">"Rozblikat zeleně hardwarové vrstvy při aktualizaci"</string>
    <string name="debug_hw_overdraw" msgid="2968692419951565417">"Ladit překreslování GPU"</string>
    <string name="disable_overlays" msgid="2074488440505934665">"Zakázat hardwarové vrstvy"</string>
    <string name="disable_overlays_summary" msgid="3578941133710758592">"Vždy použít GPU ke skládání obrazovky"</string>
    <string name="simulate_color_space" msgid="6745847141353345872">"Simulovat barevný prostor"</string>
    <string name="enable_opengl_traces_title" msgid="6790444011053219871">"Povolit trasování OpenGL"</string>
    <string name="usb_audio_disable_routing" msgid="8114498436003102671">"Směrování zvuku do USB"</string>
    <string name="usb_audio_disable_routing_summary" msgid="980282760277312264">"Vypnout automatické směrování zvuku do zvukových periferií USB"</string>
    <string name="debug_layout" msgid="5981361776594526155">"Zobrazit ohraničení"</string>
    <string name="debug_layout_summary" msgid="2001775315258637682">"Zobrazit u výstřižku ohraničení, okraje atd."</string>
    <string name="force_rtl_layout_all_locales" msgid="2259906643093138978">"Vynutit rozvržení zprava doleva"</string>
    <string name="force_rtl_layout_all_locales_summary" msgid="9192797796616132534">"Vynutit ve všech jazycích rozvržení obrazovky zprava doleva"</string>
    <string name="show_cpu_usage" msgid="2389212910758076024">"Zobrazit využití CPU"</string>
    <string name="show_cpu_usage_summary" msgid="2113341923988958266">"Překryvná vrstva s aktuálním využitím procesoru"</string>
    <string name="force_hw_ui" msgid="6426383462520888732">"Vykreslování pomocí GPU"</string>
    <string name="force_hw_ui_summary" msgid="5535991166074861515">"Vynutit použití GPU pro 2D vykreslování"</string>
    <string name="force_msaa" msgid="7920323238677284387">"Vynutit 4x MSAA"</string>
    <string name="force_msaa_summary" msgid="9123553203895817537">"Povolit 4x MSAA v aplikacích OpenGL ES 2.0"</string>
    <string name="show_non_rect_clip" msgid="505954950474595172">"Ladit operace s neobdélníkovými výstřižky"</string>
    <string name="track_frame_time" msgid="6146354853663863443">"Profil – vykreslování GPU"</string>
    <string name="window_animation_scale_title" msgid="6162587588166114700">"Měřítko animace okna"</string>
    <string name="transition_animation_scale_title" msgid="387527540523595875">"Měřítko animace přeměny"</string>
    <string name="animator_duration_scale_title" msgid="3406722410819934083">"Měřítko délky animace"</string>
    <string name="overlay_display_devices_title" msgid="5364176287998398539">"Simulovat sekundární obrazovky"</string>
    <string name="enable_multi_window" msgid="1091779249819137016">"Režim několika oken"</string>
    <string name="enable_multi_window_summary" msgid="5837641304114783514">"Několik aktivit na obrazovce současně"</string>
    <string name="confirm_enable_multi_window_title" msgid="950964546995895971">"Aktivovat režim několika oken?"</string>
    <string name="confirm_enable_multi_window_text" msgid="565834092374755117">"UPOZORNĚNÍ: Toto je vysoce experimentální funkce, která prostřednictvím uživatelského rozhraní Nedávné aplikace umožňuje, aby na obrazovce probíhalo několik aktivit současně. Při použití této funkce mohou některé aplikace selhat nebo nemusejí fungovat správně."</string>
    <string name="debug_applications_category" msgid="4206913653849771549">"Aplikace"</string>
    <string name="immediately_destroy_activities" msgid="1579659389568133959">"Neukládat aktivity"</string>
    <string name="immediately_destroy_activities_summary" msgid="3592221124808773368">"Rušit všechny činnosti, jakmile je uživatel zavře"</string>
    <string name="app_process_limit_title" msgid="4280600650253107163">"Omezení procesů na pozadí"</string>
    <string name="show_all_anrs" msgid="28462979638729082">"Zobrazit všechny ANR"</string>
    <string name="show_all_anrs_summary" msgid="641908614413544127">"Zobrazovat dialog „Aplikace neodpovídá“ pro aplikace na pozadí"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Využití dat"</string>
    <string name="data_usage_app_summary_title" msgid="4147258989837459172">"Využití dat apl."</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"Účtování dat operátora se může lišit od údajů zařízení."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Využití aplikací"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"INFORMACE O APLIKACI"</string>
    <string name="data_usage_cellular_data" msgid="4859424346276043677">"Mobilní data"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Zadejte limit dat"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Cyklus počítání dat"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Využití aplikací"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Datový roaming"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Omezení přenosů na pozadí"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Povolit data na pozadí"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Oddělit datové přenosy 4G"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Zobrazit využití Wi‑Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Skrýt použití Wi‑Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Zobrazit využití ethernetu"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Skrýt použití ethernetu"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Omezení sítě"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Automatická synchronizace dat"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"SIM karty"</string>
    <string name="data_usage_menu_cellular_networks" msgid="5243515735055652279">"Mobilní sítě"</string>
    <string name="data_usage_cellular_data_summary" msgid="8413357481361268285">"Pozastaveno při limitu"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Autom. synchronizovat data"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Autom. synch. osobní data"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Autom. synch. pracovní data"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Změnit cyklus..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Den v měsíci, kdy se má obnovit počítání datových přenosů:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"V tomto období nevyužily datové připojení žádné aplikace."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Na popředí"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Na pozadí"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"omezeno"</string>
    <string name="data_usage_disable_mobile" msgid="2613595056882494652">"Vypnout mobilní data?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="3934211003105066167">"Zadat limit mobilních dat"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Nastavit limit dat 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Nastavit limit dat 2G–3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Datový limit Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="2084466270343460491">"Mobilní"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G a 3G"</string>
    <string name="data_usage_list_mobile" msgid="7219011330831181312">"Mobilní"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Žádné"</string>
    <string name="data_usage_enable_mobile" msgid="5900650720568852325">"Mobilní data"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"Datové přenosy 2G a 3G"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"Datové přenosy 4G"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Popředí:"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"Pozadí:"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Nastavení aplikace"</string>
    <string name="data_usage_app_restrict_background" msgid="7510046552380574925">"Omezit data aplikací na pozadí"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="3720075732277934106">"Deaktivuje data na pozadí v mobilních sítích."</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="1446565717342917727">"Chcete-li u aplikace omezit data na pozadí, zadejte limit mobilních dat."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Omezit přenosy na pozadí?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5871168521456832764">"Pokud budou dostupné pouze mobilní sítě, může tato funkce způsobit, že aplikace, které data na pozadí vyžadují, nebudou fungovat.\n\nVhodnější způsoby řízení využití dat naleznete v nastavení aplikace."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="1493134803720421674">"Data na pozadí lze omezit jen v případě, že zadáte limit využití mobilních dat."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Zapnout automatickou synchronizaci dat?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"Změny, které v rámci svých účtů provedete na webu, se automaticky zkopírují do tabletu.\n\nNěkteré účty také automaticky zkopírují změny provedené v tabletu na web. Tímto způsobem funguje například účet Google."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="8651376294887142858">"Změny, které v rámci svých účtů provedete na webu, se automaticky zkopírují do telefonu.\n\nNěkteré účty také automaticky zkopírují změny provedené v telefonu na web. Tímto způsobem funguje například účet Google."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Vypnout automatickou synchronizaci dat?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4025938250775413864">"Toto nastavení šetří využití dat a baterii. Nejnovější informace však bude třeba získávat pomocí ruční synchronizace účtu. Rovněž nebudete dostávat oznámení o dostupných aktualizacích."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Datum obnovení cyklu sledování přenesených dat"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Datum v každém měsíci:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Nastavit"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Nastavit upozornění na využití dat"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Nastavení limitu datových přenosů"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Omezení spotřeby dat"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="5788774061143636263">"Až tablet dosáhne stanoveného limitu, datové připojení k mobilní síti bude vypnuto.\n\nProtože se přenesená data měří pomocí tabletu a operátor je může účtovat odlišně, je vhodné nastavit nízký limit."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3511301596446820549">"Až telefon dosáhne stanoveného limitu, datové připojení k mobilní síti bude vypnuto.\n\nProtože se přenesená data měří pomocí telefonu a operátor je může účtovat odlišně, je vhodné nastavit nízký limit."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Omezit přenosy na pozadí?"</string>
    <string name="data_usage_restrict_background" msgid="6264965779074729381">"Pokud omezíte využití mobilních dat na pozadí, některé aplikace a služby nebudou fungovat, dokud se nepřipojíte k síti Wi-Fi."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="7954930300449415764">"Pokud omezíte využití mobilních dat na pozadí, některé aplikace a služby nebudou fungovat, dokud se nepřipojíte k síti Wi-Fi.\n\nToto nastavení ovlivní všechny uživatele tohoto tabletu."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="259958321968870600">"Pokud omezíte využití mobilních dat na pozadí, některé aplikace a služby nebudou fungovat, dokud se nepřipojíte k síti Wi-Fi.\n\nToto nastavení ovlivní všechny uživatele tohoto telefonu."</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">"upozornění"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039"><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">"limit"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Odebrané aplikace"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Odebrané aplikace a odebraní uživatelé"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"Přijato <xliff:g id="RECEIVED">%1$s</xliff:g>, odesláno <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žito asi <xliff:g id="TOTAL">%1$s</xliff:g>."</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="1925687342154538972">"<xliff:g id="RANGE">%2$s</xliff:g>: podle měření tabletu využito asi <xliff:g id="TOTAL">%1$s</xliff:g>. Operátor může využití dat účtovat odlišně."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="5063981061103812900">"<xliff:g id="RANGE">%2$s</xliff:g>: podle měření telefonu využito asi <xliff:g id="TOTAL">%1$s</xliff:g>. Operátor může využití dat účtovat odlišně."</string>
    <string name="data_usage_metered_title" msgid="7383175371006596441">"Omezení sítě"</string>
    <string name="data_usage_metered_body" msgid="3262343834446126044">"Jsou-li omezena data na pozadí, budeme s měřenými sítěmi zacházet stejně jako s mobilními. Před zahájením stahování velkých souborů pomocí těchto sítí mohou aplikace zobrazit upozornění."</string>
    <string name="data_usage_metered_mobile" msgid="2326986339431119372">"Mobilní sítě"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"Měřené sítě Wi-Fi"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Chcete-li vybrat měřené sítě, zapněte připojení Wi-Fi."</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Účtování dat operátora se může lišit od údajů zařízení."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Tísňové volání"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Zpět k hovoru"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Název"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Typ"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Adresa serveru"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"Šifrování PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"Tajný klíč L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"Identifikátor protokolu IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Předsdílený klíč IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"Uživatelský certifikát 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 serveru IPSec"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Zobrazit rozšířené možnosti"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Domény vyhledávání DNS"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"Servery DNS (např. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Přesměrovávací trasy (např. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Uživatelské jméno"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Heslo"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Uložit údaje o účtu"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(nepoužíváno)"</string>
    <string name="vpn_no_ca_cert" msgid="8776029412793353361">"(neověřovat server)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(přijato ze serveru)"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Zrušit"</string>
    <string name="vpn_done" msgid="8678655203910995914">"Zavřít"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Uložit"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Připojit"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Upravit profil VPN"</string>
    <string name="vpn_forget" msgid="3684651372749415446">"Zapomenout"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Připojit k profilu <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="2555877026824771115">"Tato síť VPN bude odpojena."</string>
    <string name="vpn_disconnect" msgid="7426570492642111171">"Odpojit"</string>
    <string name="vpn_version" msgid="1939804054179766249">"Verze <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_title" msgid="6317731879966640551">"Síť VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Přidat profil VPN"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Upravit profil"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Smazat profil"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Trvalá síť VPN"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Vyberte profil VPN, ke kterému chcete zůstat trvale připojeni. Síťový provoz bude povolen pouze v případě, že budete připojeni k této síti VPN."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Žádná"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Trvalá síť VPN vyžaduje IP adresu pro server i DNS."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Připojení k síti není k dispozici. Zkuste to prosím znovu později."</string>
    <string name="vpn_missing_cert" msgid="7972907102570411501">"Chybí certifikát, upravte prosím profil."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Systém"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Uživatel"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Zakázat"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Povolit"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Odstranit"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Povolit certifikát CA systému?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Zakázat certifikát CA systému?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Natrvalo odstranit uživatelský certifikát CA?"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Kontrola pravopisu"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Sem zadejte aktuální heslo pro úplné zálohy."</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Sem zadejte nové heslo pro úplné zálohy."</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Sem znovu zadejte nové heslo pro úplné zálohy."</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Nastavit heslo pro zálohy"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Zrušit"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Další aktualizace systému"</string>
    <string name="selinux_status_disabled" msgid="924551035552323327">"Zakázáno"</string>
    <string name="selinux_status_permissive" msgid="6004965534713398778">"Mírné"</string>
    <string name="selinux_status_enforcing" msgid="2252703756208463329">"Přísné"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Síť může být monitorována"</string>
    <string name="done_button" msgid="1991471253042622230">"Hotovo"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="5339377665264149395">"Monitorování sítě"</string>
    <string name="ssl_ca_cert_info_message" msgid="4583879256548819713">"Toto zařízení je spravováno následující doménou:\n<xliff:g id="MANAGING_DOMAIN">%s</xliff:g>\n\nSprávce může monitorovat aktivitu v síti, včetně e-mailů, aplikací a zabezpečených webů.\n\nChcete-li získat další informace, kontaktujte svého správce."</string>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"Vaše aktivita v síti, včetně e-mailů, aplikací a zabezpečených webových stránek může být monitorována třetí stranou.\n\nUmožňují to důvěryhodné identifikační údaje nainstalované ve vašem zařízení."</string>
    <string name="ssl_ca_cert_settings_button" msgid="8760495070836213605">"Zkontrolovat důvěryhodné identifikační údaje"</string>
    <string name="user_settings_title" msgid="6151874007858148344">"Uživatelé"</string>
    <string name="user_list_title" msgid="7937158411137563543">"Uživatelé a profily"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Přidat uživatele nebo profil"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Přidat uživatele"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Omezený profil"</string>
    <string name="user_need_lock_message" msgid="5879715064416886811">"Před vytvořením omezeného profilu je nutné nejprve nastavit zámek obrazovky k ochraně aplikací a dat."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Nastavit zámek"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Není nastaveno"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Není nastaveno – omezený profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="1659125858619760573">"Nenastaveno – pracovní profil"</string>
    <string name="user_admin" msgid="993402590002400782">"Administrátor"</string>
    <string name="user_you" msgid="1639158809315025986">"Vy (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Přezdívka"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Přidat"</string>
    <string name="user_add_max_count" msgid="5405885348463433157">"Maximální počet přidávaných uživatelů: <xliff:g id="USER_COUNT">%1$d</xliff:g>"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Uživatelé mají své vlastní aplikace a obsah."</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Můžete omezit přístup k aplikacím a obsahu ze svého účtu"</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Uživatel"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Omezený profil"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"Přidat nového uživatele?"</string>
    <string name="user_add_user_message_long" msgid="8562152293752222985">"Vytvořením dalších uživatelů můžete toto zařízení sdílet s jinými lidmi. Každý uživatel má svůj prostor, který si může přizpůsobit instalací aplikací, přidáním tapety apod. Uživatelé také mohou upravit nastavení zařízení (např. Wi-Fi), která ovlivní všechny uživatele.\n\nKaždý nově přidaný uživatel si musí nastavit vlastní prostor.\n\nKaždý uživatel může aktualizovat aplikace všech ostatních uživatelů."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Když přidáte nového uživatele, musí si nastavit vlastní prostor.\n\nJakýkoli uživatel může aktualizovat aplikace všech ostatních uživatelů."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Nastavit uživatele?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"Ujistěte se, že je uživatel k dispozici a může si v zařízení nastavit svůj prostor"</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Nastavit profil?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Nastavit"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Nyní ne"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="7153048188252553320">"Uživatele smí spravovat pouze vlastník tabletu."</string>
    <string name="user_cannot_manage_message" product="default" msgid="959315813089950649">"Uživatele smí spravovat pouze vlastník telefonu."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Pomocí omezených profilů nelze přidávat účty."</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Smazat <xliff:g id="USER_NAME">%1$s</xliff:g> ze zařízení"</string>
    <string name="user_add_on_lockscreen_menu" msgid="3025132738715222247">"Přid. uživatele i při uzamčení"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Nový uživatel"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Nový profil"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Chcete se smazat?"</string>
    <string name="user_confirm_remove_title" msgid="1163721647646152032">"Odstranit uživatele?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Odstranit tento profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"Odstranit pracovní profil?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="2391372805233812410">"Přijdete o místo a data v tomto tabletu. Tuto akci nelze vrátit zpět."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="7943645442479360048">"Přijdete o místo a data v tomto telefonu. Tuto akci nelze vrátit zpět."</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"Budou smazány všechny aplikace a data."</string>
    <string name="work_profile_confirm_remove_message" msgid="323856589749078140">"Budete-li pokračovat, budou smazány všechny aplikace a data z tohoto profilu."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"Budou smazány všechny aplikace a data."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Přidávání nového uživatele…"</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Smazat uživatele"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Smazat"</string>
    <string name="user_guest" msgid="8475274842845401871">"Host"</string>
    <string name="user_exit_guest_title" msgid="5613997155527410675">"Odstranit hosta"</string>
    <string name="user_exit_guest_confirm_title" msgid="3405527634738147409">"Odstranit hosta?"</string>
    <string name="user_exit_guest_confirm_message" msgid="2194459201944413257">"Veškeré aplikace a data v této relaci budou vymazána."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Odstranit"</string>
    <string name="user_enable_calling" msgid="5128605672081602348">"Zapnout telefonní hovory"</string>
    <string name="user_enable_calling_sms" msgid="9172507088023097063">"Zapnout telefonní hovory a SMS"</string>
    <string name="user_remove_user" msgid="6490483480937295389">"Odstranit uživatele"</string>
    <string name="user_enable_calling_confirm_title" msgid="4315789475268695378">"Zapnout telefonní hovory?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"S tímto uživatelem bude sdílena historie hovorů."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="7243308401401932681">"Zapnout telefonní hovory a SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="4025082715546544967">"S tímto uživatelem bude sdílena historie hovorů a SMS."</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Povolit aplikace a obsah"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Aplikace s omezením"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Rozbalit nastavení aplikace"</string>
    <string name="home_app_uninstall_button" msgid="6808453012607962899">"Odinstalovat aplikaci"</string>
    <string name="only_one_home_message" msgid="3538846733750242759">"Nastavení plochy budou skryta, dokud nenainstalujete další aplikaci plochy"</string>
    <string name="global_change_warning" product="tablet" msgid="8045013389464294039">"Toto nastavení ovlivní všechny uživatele tohoto tabletu."</string>
    <string name="global_change_warning" product="default" msgid="2461264421590324675">"Toto nastavení ovlivní všechny uživatele tohoto telefonu."</string>
    <string name="global_locale_change_title" msgid="5956281361384221451">"Změna jazyka"</string>
    <string name="global_font_change_title" msgid="1887126466191012035">"Změna velikosti písma"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Platby mobilem"</string>
    <string name="nfc_payment_how_it_works" msgid="3028822263837896720">"Jak to funguje"</string>
    <string name="nfc_payment_no_apps" msgid="3453656795093776889">"Plaťte za nákupy v kamenných prodejnách mobilem"</string>
    <string name="nfc_payment_default" msgid="8648420259219150395">"Výchozí platební aplikace"</string>
    <string name="nfc_payment_default_not_set" msgid="7485060884228447765">"Nenastaveno"</string>
    <string name="nfc_payment_app_and_desc" msgid="7942415346564794258">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_open_app" msgid="5550268485421927976">"Pokud otevřená aplikace podporuje platby mobilem"</string>
    <string name="nfc_payment_favor_open" msgid="7513784422533299982">"Použít namísto aplikace <xliff:g id="APP">%1$s</xliff:g> danou aplikaci"</string>
    <string name="nfc_payment_favor_open_default_unknown" msgid="1179489206233351756">"Použít namísto výchozí aplikace danou aplikaci"</string>
    <string name="nfc_payment_favor_default" msgid="8238320071435721803">"Použít aplikaci <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_favor_default_default_unknown" msgid="7029467023485683077">"Použít výchozí aplikaci"</string>
    <string name="nfc_payment_pay_with" msgid="7524904024378144072">"Aplikace, která bude použita u terminálu pro platby mobilem:"</string>
    <string name="nfc_how_it_works_title" msgid="1984068457698797207">"Platba na terminálu"</string>
    <string name="nfc_how_it_works_content" msgid="5820288675316257177">"Pokud je nastavena aplikace pro platby mobilem a telefon je zapnutý, můžete za nákup zaplatit tím, že se telefonem dotknete libovolného terminálu s logem plateb mobilem."</string>
    <string name="nfc_how_it_works_got_it" msgid="259653300203217402">"Rozumím"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Další..."</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Nastavit jako předvolbu?"</string>
    <string name="nfc_payment_set_default" msgid="8532426406310833489">"Chcete při platbě mobilem vždy používat aplikaci <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="6993301165940432743">"Chcete při platbě mobilem namísto aplikace <xliff:g id="APP_0">%1$s</xliff:g> vždy používat aplikaci <xliff:g id="APP_1">%2$s</xliff:g>?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Omezení"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Odebrat omezení"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Změnit PIN"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Zobrazovat oznámení"</string>
    <string name="help_label" msgid="6886837949306318591">"Nápověda a zpětná vazba"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Účet pro obsah"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID fotografie"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Extrémní ohrožení"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Přijímat upozornění na extrémní ohrožení života a majetku"</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Závažná ohrožení"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Přijímat upozornění na závažná ohrožení života a majetku"</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"Upozornění AMBER"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Přijímat bulletiny o únosech dětí"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Opakovat"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Aktivovat Správce hovorů"</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Povolí této službě spravovat způsob uskutečňování hovorů."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Správce hovorů"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2451014351355183338">"Výstražné zprávy o výjimečné situaci"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Síťoví operátoři"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Názvy přístupových bodů"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="5808043757309522392">"Vylepšený režim 4G LTE"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1376589643017218924">"Vylepšit kvalitu hovorů a zpráv pomocí datového připojení LTE (doporučeno)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Preferovaný typ sítě"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (doporučeno)"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"Pracovní SIM karta"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Přístup k aplikacím a obsahu"</string>
    <string name="user_rename" msgid="8523499513614655279">"PŘEJMENOVAT"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Nastavit omezení aplikací"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Řízeno aplikací <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Tato aplikace má přístup k vašim účtům"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="6968697624437267294">"Tato aplikace má přístup k vašim účtům. Řízeno aplikací <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"Sítě Wi‑Fi a mobilní sítě"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Povolit úpravu nastavení sítí Wi-Fi a mobilních sítí"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Povolit úpravy párování a nastavení zařízení Bluetooth"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Povolit výměnu dat, když se toto zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> dotkne jiného zařízení s funkcí NFC."</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Povolit výměnu dat, pokud se tablet dotkne jiného zařízení"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Povolit výměnu dat, pokud se telefon dotkne jiného zařízení"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Poloha"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Povolit aplikaci používat informace o vaší poloze"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Zpět"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Další"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Dokončit"</string>
    <string name="user_image_take_photo" msgid="1280274310152803669">"Vyfotit"</string>
    <string name="user_image_choose_photo" msgid="7940990613897477057">"Vybrat fotografii z Galerie"</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Vybrat fotografii"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"SIM karty"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"SIM karty"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<xliff:g id="SIM_NAME">%1$s</xliff:g> – <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7900721153345139783">"Došlo k výměně SIM karet"</string>
    <string name="sim_cards_changed_message_summary" msgid="5452545583546944683">"Klepnutím nastavte aktivity"</string>
    <string name="sim_cellular_data_unavailable" msgid="9018555543451203035">"Mobilní datové připojení je nedostupné"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="3654805961942166428">"Klepnutím vyberte datovou SIM kartu"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Vždy používat pro hovory"</string>
    <string name="select_sim_for_data" msgid="2366081042162853044">"Vyberte SIM kartu pro data"</string>
    <string name="data_switch_started" msgid="2040761479817166311">"Přepínání datových SIM karet, tato operace může chvíli trvat..."</string>
    <string name="select_sim_for_calls" msgid="3503094771801109334">"Volat pomocí"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Vyberte SIM kartu"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"SIM karta <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"Prázdná SIM"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Název SIM karty"</string>
    <string name="sim_name_hint" msgid="7038643345238968930">"Zadejte název SIM karty"</string>
    <string name="sim_editor_title" msgid="4034301817366627870">"Slot pro SIM kartu %1$d"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Operátor"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Číslo"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"Barva SIM karty"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"Vybrat SIM kartu"</string>
    <string name="color_orange" msgid="4417567658855022517">"Oranžová"</string>
    <string name="color_purple" msgid="3888532466427762504">"Nachová"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"Nejsou vloženy žádné SIM karty"</string>
    <string name="sim_status_title" msgid="6744870675182447160">"Stav SIM karty"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Volat zpět z výchozí SIM karty"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"SIM karta pro odchozí hovory"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Další nastavení hovorů"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"Preferované zatížení sítě"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Zakázat vysílání názvu sítě"</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"Zakázáním vysílání názvu sítě zabráníte třetím stranám v zobrazení informací o vaší síti."</string>
    <string name="preferred_network_offload_popup" msgid="2252915199889604600">"Zakázáním vysílání názvu sítě zabráníte automatickému připojování ke skrytým sítím."</string>
    <string name="sim_signal_strength" msgid="9144010043784767984">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="6272913297433198340">"SIM karty byly změněny."</string>
    <string name="sim_notification_summary" msgid="5024470200658902406">"Nastavte dotykem"</string>
    <string name="sim_pref_divider" msgid="6778907671867621874">"Preferovaná SIM karta"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="7941299533514115976">"Pokaždé se zeptat"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Vyžadován výběr"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Nastavení"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Nastavení"</string>
    <string name="search_menu" msgid="6283419262313758339">"Nastavení vyhledávání"</string>
    <string name="query_hint_text" msgid="3350700807437473939">"Vyhledávání nastavení"</string>
    <string name="search_recents_queries_label" msgid="2128811638532309069">"Poslední vyhledávání"</string>
    <string name="search_results_label" msgid="4163304782363526148">"Výsledky"</string>
    <string name="keywords_wifi" msgid="8947676711698613374">"wifi wi-fi síť připojení"</string>
    <string name="keywords_more_default_sms_app" msgid="895656981962034647">"textová zpráva SMS odesílání zpráv"</string>
    <string name="keywords_more_mobile_networks" msgid="4939725094449606744">"mobilní operátor mobilní data bezdrátový přenos 4g 3g 2g lte"</string>
    <string name="keywords_wifi_calling" msgid="5497735076883598019">"wifi wi-fi hovor volání"</string>
    <string name="keywords_home" msgid="3626170808219458848">"launcher"</string>
    <string name="keywords_display" msgid="6709007669501628320">"obrazovka dotykový displej"</string>
    <string name="keywords_display_brightness_level" msgid="8923289340474728990">"ztlumit obrazovka dotykový displej baterie"</string>
    <string name="keywords_display_auto_brightness" msgid="8357056338746666901">"ztlumit obrazovka dotykový displej baterie"</string>
    <string name="keywords_display_night_mode" msgid="7652025075378505346">"tmavý motiv noční režim ztlumení obrazovky invertovat jas"</string>
    <string name="keywords_display_wallpaper" msgid="7778443098569037063">"pozadí personalizace přizpůsobení displej"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"velikost textu"</string>
    <string name="keywords_display_cast_screen" msgid="3167261692257302743">"promítání vysílání"</string>
    <string name="keywords_storage" msgid="6572905220031852173">"místo disk pevný disk zařízení využití"</string>
    <string name="keywords_battery" msgid="2096185085932675704">"využití energie nabití"</string>
    <string name="keywords_spell_checker" msgid="6106749039734174140">"pravopis slovník kontrola pravopisu automatické opravy"</string>
    <string name="keywords_voice_input" msgid="3519547605812413860">"recognizer input speech speak language hands-free hand free recognition offensive word audio history bluetooth headset"</string>
    <string name="keywords_text_to_speech_output" msgid="392447904221657930">"sazba jazyk výchozí řeč mluvit tts usnadnění přístupnost čtečka nevidomí"</string>
    <string name="keywords_date_and_time" msgid="2631808108134830066">"hodiny čas"</string>
    <string name="keywords_network_reset" msgid="6346978754090557056">"resetovat obnovení továrního nastavení"</string>
    <string name="keywords_factory_data_reset" msgid="4355133848707691977">"smazat vymazat obnovit vymazání odstranění"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"tiskárna"</string>
    <string name="keywords_sounds_and_notifications" msgid="5965996187974887000">"reproduktor pípnutí"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="543023766902917716">"nerušit vyrušení vyrušit"</string>
    <string name="keywords_app" msgid="6334757056536837791">"RAM"</string>
    <string name="keywords_location" msgid="782326973714313480">"okolí poloha historie hlášení"</string>
    <string name="keywords_location_mode" msgid="8584992704568356084">"přesnost"</string>
    <string name="keywords_accounts" msgid="1957925565953357627">"účet"</string>
    <string name="keywords_users" msgid="4673901601478559100">"omezení omezit omezeno"</string>
    <string name="keywords_keyboard_and_ime" msgid="5251531893531063855">"oprava textu opravit zvuk vibrace automatický výběr jazyka návrh navrhování motiv nevhodné slovo psaní emodži mezinárodní"</string>
    <string name="keywords_reset_apps" msgid="6420313678620788457">"resetovat předvolby výchozí"</string>
    <string name="keywords_emergency_app" msgid="6542122071127391103">"výstražné nouzové aplikace výchozí"</string>
    <string name="keywords_default_phone_app" msgid="90136554927956860">"výchozí nastavení vytáčení"</string>
    <string name="keywords_all_apps" msgid="5377153522551809915">"aplikace stahování systém"</string>
    <string name="keywords_app_permissions" msgid="8677901415217188314">"aplikace oprávnění zabezpečení"</string>
    <string name="keywords_default_apps" msgid="3581727483175522599">"aplikace výchozí"</string>
    <string name="keywords_ignore_optimizations" msgid="946516741848647905">"ignorování optimalizací schrupnutí aplikace v pohotovostním režimu"</string>
    <string name="keywords_lockscreen" msgid="4806191868723291541">"přejetí prstem heslo gesto pin"</string>
    <string name="setup_wifi_nfc_tag" msgid="9028353016222911016">"Nastavení štítku NFC pro Wi-Fi"</string>
    <string name="write_tag" msgid="8571858602896222537">"Zapsat"</string>
    <string name="status_awaiting_tap" msgid="2130145523773160617">"Klepnutím na štítek zahájíte zápis..."</string>
    <string name="status_invalid_password" msgid="2575271864572897406">"Neplatné heslo, zkuste to znovu."</string>
    <string name="status_write_success" msgid="5228419086308251169">"Povedlo se!"</string>
    <string name="status_failed_to_write" msgid="8072752734686294718">"Zápis dat na štítek NFC se nezdařil. Pokud problém přetrvává, zkuste jiný štítek."</string>
    <string name="status_tag_not_writable" msgid="2511611539977682175">"Na štítek NFC nelze zapisovat. Zkuste jiný štítek."</string>
    <string name="default_sound" msgid="8821684447333687810">"Výchozí zvuk"</string>
    <string name="notification_settings" msgid="8791730980212496561">"Zvuk a oznámení"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Hlasitost médií"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Hlasitost budíku"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Hlasitost vyzvánění"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Hlasitost oznámení"</string>
    <string name="zen_mode_priority_settings_title" msgid="2623117023031824309">"Pouze prioritní"</string>
    <string name="zen_mode_automation_settings_title" msgid="4228995740594063774">"Automatická pravidla"</string>
    <string name="zen_mode_option_important_interruptions" msgid="3903928008177972500">"Pouze prioritní"</string>
    <string name="zen_mode_option_alarms" msgid="5785372117288803600">"Pouze budíky"</string>
    <string name="zen_mode_option_no_interruptions" msgid="8107126344850276878">"Úplné ticho"</string>
    <string name="zen_mode_summary_combination" msgid="8715563402849273459">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Vyzváněcí tón telefonu"</string>
    <string name="notification_ringtone_title" msgid="3361201340352664272">"Výchozí tón oznámení"</string>
    <string name="vibrate_when_ringing_title" msgid="3806079144545849032">"Vibrovat také u volání"</string>
    <string name="notification_section_header" msgid="95661783916799134">"Oznámení"</string>
    <string name="advanced_section_header" msgid="8833934850242546903">"Rozšířená nastavení"</string>
    <string name="notification_pulse_title" msgid="1247988024534030629">"Blikat kontrolkou oznámení"</string>
    <string name="lock_screen_notifications_title" msgid="9118805570775519455">"Když je zařízení zamčeno"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Zobrazit veškerý obsah oznámení"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7891552853357258782">"Skrýt citlivý obsah oznámení"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="859628910427886715">"Oznámení vůbec nezobrazovat"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6164532459432182244">"Jak chcete zobrazovat oznámení, když bude zařízení uzamčeno?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1416589393106326972">"Oznámení"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Oznámení"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Ostatní zvuky"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Tóny číselníku"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Zvuky zámku obrazovky"</string>
    <string name="charging_sounds_title" msgid="1132272552057504251">"Zvuky při nabíjení"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Zvuky při vložení do doku"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Zvuky při dotyku"</string>
    <string name="vibrate_on_touch_title" msgid="674710566941697253">"Vibrace při dotyku"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Zvuk reproduktoru doku"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Veškerý zvuk"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Pouze mediální soubory"</string>
    <string name="emergency_tone_silent" msgid="1067515631635824291">"Tichý režim"</string>
    <string name="emergency_tone_alert" msgid="8941852695428130667">"Upozornění"</string>
    <string name="emergency_tone_vibrate" msgid="8281126443204950847">"Vibrace"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Přístup k oznámením"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Aplikace nesmí číst oznámení"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="7930130030691218387">
      <item quantity="few">%d aplikace mohou číst oznámení</item>
      <item quantity="many">%d aplikace může číst oznámení</item>
      <item quantity="other">%d aplikací může číst oznámení</item>
      <item quantity="one">%d aplikace může číst oznámení</item>
    </plurals>
    <string name="no_notification_listeners" msgid="3487091564454192821">"Žádné nainstalované aplikace o přístup k oznámením nepožádaly."</string>
    <string name="notification_listener_security_warning_title" msgid="5522924135145843279">"Povolit službě <xliff:g id="SERVICE">%1$s</xliff:g> přístup k oznámením?"</string>
    <string name="notification_listener_security_warning_summary" msgid="548925084229440829">"Aplikace <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> bude moci číst všechna oznámení, včetně osobních údajů, jako jsou jména kontaktů a texty zpráv, které obdržíte. Bude také moci oznámení zavřít nebo aktivovat tlačítka akcí, která obsahují."</string>
    <string name="manage_zen_access_title" msgid="2611116122628520522">"Přístup při nastavení Nerušit"</string>
    <string name="zen_access_empty_text" msgid="8772967285742259540">"O přístup při nastavení Nerušit nepožádaly žádné nainstalované aplikace"</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Načítání aplikací..."</string>
    <string name="app_notification_block_title" msgid="4069351066849087649">"Blokovat vše"</string>
    <string name="app_notification_block_summary" msgid="9049487483231233726">"Nikdy nezobrazovat oznámení z této aplikace"</string>
    <string name="app_notification_priority_title" msgid="5949923919607295595">"Považovat za prioritní"</string>
    <string name="app_notification_priority_summary" msgid="2538018111338754446">"Umožní aplikaci informovat o oznámeních, i když je režim Nerušit nastaven pouze na prioritní vyrušení."</string>
    <string name="app_notification_peekable_title" msgid="8647856880382324822">"Povolit rychlý náhled"</string>
    <string name="app_notification_peekable_summary" msgid="678845517890921158">"Umožní aplikaci zdůraznit určitá upozornění tím, že je krátce zobrazí na aktuální obrazovce."</string>
    <string name="app_notification_sensitive_title" msgid="8465860579482264139">"Skrýt citlivý obsah"</string>
    <string name="app_notification_sensitive_summary" msgid="3263836642625157920">"Když je zařízení uzamčeno, skryje se obsah oznámení této aplikace, která by mohla vyzradit soukromé údaje."</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"Blokované"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Prioritní"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Důvěrné"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"Hotovo"</string>
    <string name="zen_mode_rule_name" msgid="5149068059383837549">"Název pravidla"</string>
    <string name="zen_mode_rule_name_hint" msgid="3781174510556433384">"Zadejte název pravidla"</string>
    <string name="zen_mode_rule_name_warning" msgid="4517805381294494314">"Název pravidla je již používán."</string>
    <string name="zen_mode_add_rule" msgid="9100929184624317193">"Přidat pravidlo"</string>
    <string name="zen_mode_delete_rule" msgid="2985902330199039533">"Smazat pravidlo"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6237882294348570283">"Smazat pravidlo <xliff:g id="RULE">%1$s</xliff:g>?"</string>
    <string name="zen_mode_delete_rule_button" msgid="4248741120307752294">"Smazat"</string>
    <string name="zen_mode_rule_type" msgid="2289413469580142888">"Typ pravidla"</string>
    <string name="zen_mode_rule_type_unknown" msgid="3049377282766700600">"Neznámé"</string>
    <string name="zen_mode_configure_rule" msgid="8865785428056490305">"Nakonfigurovat pravidlo"</string>
    <string name="zen_schedule_rule_type_name" msgid="142936744435271449">"Časové pravidlo"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="3379499360390382259">"Automatické pravidlo bylo nastaveno na Nerušit v určitých časech"</string>
    <string name="zen_event_rule_type_name" msgid="2645981990973086797">"Pravidlo pro události"</string>
    <string name="zen_event_rule_enabled_toast" msgid="6910577623330811480">"Automatické pravidlo bylo nastaveno na Nerušit během určitých událostí"</string>
    <string name="zen_mode_event_rule_calendar" msgid="8787906563769067418">"Během událostí"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="5135844750232403975">"Během událostí <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="4936646399126636358">"v libovolném kalendáři"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="6590671260829837157">"V případě odpovědi <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="6485568415998569885">"V libovolném kalendáři"</string>
    <string name="zen_mode_event_rule_reply" msgid="5166322024212403739">"V případě odpovědi"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="8868873496008825961">"Ano, možná nebo žádná odpověď"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="2769656565454495824">"Ano nebo možná"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="1003598835878784659">"Ano"</string>
    <string name="zen_mode_rule_not_found_text" msgid="8963662446092059836">"Pravidlo nebylo nalezeno."</string>
    <string name="zen_mode_rule_summary_combination" msgid="2526506268333198254">"<xliff:g id="DESCRIPTION">%1$s</xliff:g> / <xliff:g id="MODE">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="3195058680641389948">"Dny"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="4954143628634166317">"Žádná"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="146511166522076034">"Každý den"</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="summary_range_symbol_combination" msgid="5695218513421897027">"<xliff:g id="START">%1$s</xliff:g> – <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="8467306662961568656">"<xliff:g id="START">%1$s</xliff:g> až <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_calls" msgid="7051492091133751208">"Volání"</string>
    <string name="zen_mode_messages" msgid="5886440273537510894">"Zprávy"</string>
    <string name="zen_mode_selected_messages" msgid="8245990149599142281">"Vybrané zprávy"</string>
    <string name="zen_mode_from_anyone" msgid="2638322015361252161">"Od kohokoli"</string>
    <string name="zen_mode_from_contacts" msgid="2232335406106711637">"Pouze od kontaktů"</string>
    <string name="zen_mode_from_starred" msgid="2678345811950997027">"Pouze od oblíbených kontaktů"</string>
    <string name="zen_mode_from_none" msgid="8219706639954614136">"Žádné"</string>
    <string name="zen_mode_alarms" msgid="2165302777886552926">"Budíky"</string>
    <string name="zen_mode_reminders" msgid="5458502056440485730">"Připomenutí"</string>
    <string name="zen_mode_events" msgid="7914446030988618264">"Události"</string>
    <string name="zen_mode_selected_callers" msgid="3127598874060615742">"Vybraní volající"</string>
    <string name="zen_mode_repeat_callers" msgid="5019521886428322131">"Volající, kteří volají opakovaně"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="7192713032364140137">"Pokud stejná osoba zavolá podruhé během <xliff:g id="MINUTES">%d</xliff:g> min, bude povolena"</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Automaticky zapnout"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Nikdy"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Každou noc"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Víkendy"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Čas zahájení"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Čas ukončení"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="4201521691238728701">"Následující den v <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="2061973221027570123">"Přepnout do režimu Pouze budíky na dobu neurčitou"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="6122003583875424601">
      <item quantity="few">Na <xliff:g id="DURATION">%1$d</xliff:g> minuty (tedy do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
      <item quantity="many">Na <xliff:g id="DURATION">%1$d</xliff:g> minuty (tedy do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
      <item quantity="other">Na <xliff:g id="DURATION">%1$d</xliff:g> minut (tedy do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
      <item quantity="one">Na minutu (tedy do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
    </plurals>
    <plurals name="zen_mode_summary_alarms_only_by_hour" formatted="false" msgid="2407703455581767748">
      <item quantity="few">Na <xliff:g id="DURATION">%1$d</xliff:g> hodiny (tedy do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
      <item quantity="many">Na <xliff:g id="DURATION">%1$d</xliff:g> hodiny (tedy do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
      <item quantity="other">Na <xliff:g id="DURATION">%1$d</xliff:g> hodin (tedy do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
      <item quantity="one">Na hodinu (tedy do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
    </plurals>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="7465525754879341907">"Přepnout do režimu Pouze budíky až do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="6172985102689237703">"Přejít do režimu Vždy vyrušit"</string>
    <string name="notification_settings_apps_title" msgid="1125354590652967250">"Oznámení"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Nastavení oznámení"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Odeslat zpětnou vazbu o tomto zařízení"</string>
    <string name="restr_pin_enter_admin_pin" msgid="2451187374960131018">"Zadejte PIN administrátora"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Zapnuto"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Vypnuto"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Připnutí obrazovky"</string>
    <string name="screen_pinning_description" msgid="1137904524037468263">"Pokud je toto nastavení zapnuto, můžete pomocí připnutí obrazovky zajistit zobrazení aktuální obrazovky, dokud ji neuvolníte.\n\nPostup připnutí obrazovky:\n\n1. Zkontrolujte, zda je funkce připnutí obrazovky zapnutá.\n\n2. Otevřete obrazovku, kterou chcete připnout.\n\n3. Klepněte na Přehled.\n\n4. Přejeďte prstem nahoru a poté klepněte na ikonu špendlíku."</string>
    <string name="screen_pinning_unlock_pattern" msgid="8282268570060313339">"Před uvolněním požádat o bezpečnostní gesto"</string>
    <string name="screen_pinning_unlock_pin" msgid="8757588350454795286">"Před uvolněním požádat o PIN"</string>
    <string name="screen_pinning_unlock_password" msgid="2514079566873826434">"Před uvolněním požádat o heslo"</string>
    <string name="screen_pinning_unlock_none" msgid="3814188275713871856">"Při uvolnění uzamknout zařízení"</string>
    <string name="managed_user_title" msgid="8101244883654409696">"Pracovní profil"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2232461523882170874">"Tento pracovní profil je spravován pomocí aplikace:"</string>
    <string name="managing_admin" msgid="8843802210377459055">"Spravováno aplikací <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Experimentální)"</string>
    <string name="display_auto_rotate_title" msgid="6176450657107806043">"Při otočení zařízení"</string>
    <string name="display_auto_rotate_rotate" msgid="4544299861233497728">"Otočit obsah obrazovky"</string>
    <string name="display_auto_rotate_stay_in_portrait" msgid="292745182318093651">"Zachovat orientaci na výšku"</string>
    <string name="display_auto_rotate_stay_in_landscape" msgid="3804752830204062162">"Zachovat orientaci na šířku"</string>
    <string name="display_auto_rotate_stay_in_current" msgid="317932372686498096">"Zachovat aktuální orientaci"</string>
    <string name="imei_information_title" msgid="8499085421609752290">"Informace o kódu IMEI"</string>
    <string name="encryption_interstitial_header" msgid="468015813904595613">"Bezpečné spuštění"</string>
    <string name="encryption_continue_button" msgid="1121880322636992402">"Pokračovat"</string>
    <string name="encryption_interstitial_message_pin" msgid="7164072567822375682">"Toto zařízení můžete dále ochránit tím, že před jeho spuštěním bude požadován kód PIN. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků. \n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních."</string>
    <string name="encryption_interstitial_message_pattern" msgid="6747091924626566031">"Toto zařízení můžete dále ochránit tím, že před jeho spuštěním bude požadováno gesto. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků. \n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních."</string>
    <string name="encryption_interstitial_message_password" msgid="3462225324186045679">"Toto zařízení můžete dále ochránit tím, že před jeho spuštěním bude požadováno heslo. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků. \n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních."</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="3775537118799831558">"Kromě odemykání pomocí otisku prstu můžete toto zařízení dále ochránit tak, že před jeho spuštěním bude požadován kód PIN. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků.\n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních."</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="1105290967535237237">"Kromě odemykání pomocí otisku prstu můžete toto zařízení dále ochránit tak, že před jeho spuštěním bude požadováno gesto. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků.\n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních."</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="3512482682507378424">"Kromě odemykání pomocí otisku prstu můžete toto zařízení dále ochránit tak, že před jeho spuštěním bude požadováno heslo. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků.\n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních."</string>
    <string name="encrypt_require_pin" msgid="2063945047845243752">"Při spuštění zařízení požadovat kód PIN"</string>
    <string name="encrypt_require_pattern" msgid="6898479411004015810">"Při spuštění zařízení požadovat gesto"</string>
    <string name="encrypt_require_password" msgid="8770628366276570518">"Při spuštění zařízení požadovat heslo"</string>
    <string name="encrypt_dont_require_pin" msgid="1082444817726247368">"Ne, děkuji"</string>
    <string name="encrypt_dont_require_pattern" msgid="6668299362640433843">"Ne, děkuji"</string>
    <string name="encrypt_dont_require_password" msgid="2580403214917009046">"Ne, děkuji"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"Požadovat kód PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"Požadovat gesto?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"Požadovat heslo?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="7582096542997635316">"Při zadávání kódu PIN ke spuštění zařízení ještě služby přístupnosti, jako je <xliff:g id="SERVICE">%1$s</xliff:g>, nebudou k dispozici."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="2020083142199612743">"Při zadávání gesta ke spuštění zařízení ještě služby přístupnosti, jako je <xliff:g id="SERVICE">%1$s</xliff:g>, nebudou k dispozici."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="4155875981789127796">"Při zadávání hesla ke spuštění zařízení ještě služby přístupnosti, jako je <xliff:g id="SERVICE">%1$s</xliff:g>, nebudou k dispozici."</string>
    <string name="imei_information_title" msgid="8499085421609752290">"Informace o kódu IMEI"</string>
    <string name="imei_information_summary" msgid="2074095606556565233">"Informace související s kódem IMEI"</string>
    <string name="slot_number" msgid="3762676044904653577">"(Slot <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="1840761193189009248">"Otevírat ve výchozím nastavení"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"<xliff:g id="STORAGE_TYPE">%2$s</xliff:g> – využito <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="app_launch_domain_links_title" msgid="6789955009107320092">"Odkazy aplikací"</string>
    <string name="app_launch_open_domain_urls_title" msgid="8914721351596745701">"Otevírání podporovaných odkazů"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="5367573364240712217">"Otevírat bez dotazu"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="8250695258211477480">"Podporované odkazy"</string>
    <string name="app_launch_other_defaults_title" msgid="2516812499807835178">"Další výchozí hodnoty"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"<xliff:g id="STORAGE_TYPE">%2$s</xliff:g> – využito <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="410824961149037234">"Interní paměť"</string>
    <string name="storage_type_external" msgid="8928374515368986503">"Externí paměť"</string>
    <string name="storage_type_internal" msgid="6042049833565674948">"Interní úložiště"</string>
    <string name="storage_type_external" msgid="7738894330670001898">"Externí úložiště"</string>
    <string name="app_data_usage" msgid="7942375313697452803">"Využití dat aplikací"</string>
    <string name="data_summary_format" msgid="6213211533341068366">"Od <xliff:g id="DATE">%2$s</xliff:g> využito <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="storage_used" msgid="7128074132917008743">"Využití úložiště"</string>
    <string name="change" msgid="6657848623929839991">"Změnit"</string>
    <string name="change_storage" msgid="600475265207060436">"Změnit úložiště"</string>
    <string name="notifications_label" msgid="2872668710589600731">"Oznámení"</string>
    <string name="notifications_enabled" msgid="4386196629684749507">"Normální"</string>
    <string name="notifications_disabled" msgid="4326096527874762629">"Blokováno"</string>
    <string name="notifications_sensitive" msgid="7636231039287237132">"Citlivý obsah byl skryt"</string>
    <string name="notifications_priority" msgid="1812498477331421719">"Prioritní"</string>
    <string name="notifications_no_peeking" msgid="999951669023262823">"Rychlý náhled zakázán"</string>
    <string name="notifications_two_items" msgid="4619842959192163127">"<xliff:g id="NOTIF_STATE_0">%1$s</xliff:g> / <xliff:g id="NOTIF_STATE_1">%2$s</xliff:g>"</string>
    <string name="notifications_three_items" msgid="7536490263864218246">"<xliff:g id="NOTIF_STATE_0">%1$s</xliff:g> / <xliff:g id="NOTIF_STATE_1">%2$s</xliff:g> / <xliff:g id="NOTIF_STATE_2">%3$s</xliff:g>"</string>
    <plurals name="permissions_summary" formatted="false" msgid="6402730318075959117">
      <item quantity="few">Udělena <xliff:g id="COUNT_1">%d</xliff:g> oprávnění</item>
      <item quantity="many">Uděleno <xliff:g id="COUNT_1">%d</xliff:g> oprávnění</item>
      <item quantity="other">Uděleno <xliff:g id="COUNT_1">%d</xliff:g> oprávnění</item>
      <item quantity="one">Uděleno <xliff:g id="COUNT_0">%d</xliff:g> oprávnění</item>
    </plurals>
    <plurals name="runtime_permissions_summary" formatted="false" msgid="1564663886246010959">
      <item quantity="few">Bylo uděleno <xliff:g id="COUNT_2">%d</xliff:g> z <xliff:g id="COUNT_3">%d</xliff:g> oprávnění</item>
      <item quantity="many">Bylo uděleno <xliff:g id="COUNT_2">%d</xliff:g> z <xliff:g id="COUNT_3">%d</xliff:g> oprávnění</item>
      <item quantity="other">Bylo uděleno <xliff:g id="COUNT_2">%d</xliff:g> z <xliff:g id="COUNT_3">%d</xliff:g> oprávnění</item>
      <item quantity="one">Bylo uděleno <xliff:g id="COUNT_0">%d</xliff:g> z <xliff:g id="COUNT_1">%d</xliff:g> oprávnění</item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="931276038884210752">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> další oprávnění</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> dalšího oprávnění</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> dalších oprávnění</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> další oprávnění</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="1679758182657005375">"Nebyla udělena žádná oprávnění"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7655100570513818534">"Nevyžaduje žádná oprávnění"</string>
    <string name="launch_defaults_some" msgid="313159469856372621">"Je nastaveno několik výchozích hodnot"</string>
    <string name="launch_defaults_none" msgid="4241129108140034876">"Nejsou nastaveny žádné výchozí hodnoty"</string>
    <string name="filter_all_apps" msgid="1988403195820688644">"Všechny aplikace"</string>
    <string name="filter_enabled_apps" msgid="3318021007093070639">"Zapnuto"</string>
    <string name="filter_personal_apps" msgid="3277727374174355971">"Osobní"</string>
    <string name="filter_work_apps" msgid="24519936790795574">"Práce"</string>
    <string name="filter_notif_blocked_apps" msgid="3446926933792244485">"Blokované"</string>
    <string name="filter_notif_priority_apps" msgid="5965001885749195239">"Prioritní"</string>
    <string name="filter_notif_sensitive_apps" msgid="4909289478844197927">"Citlivý obsah byl skryt"</string>
    <string name="filter_notif_no_peeking" msgid="5197968265625096563">"Bez rychlého náhledu"</string>
    <string name="filter_with_domain_urls_apps" msgid="4573276638806792792">"S adresami URL domény"</string>
    <string name="trust_agent_disabled_device_admin" msgid="5982562414642596563">"Zakázáno administrátorem"</string>
    <string name="advanced_apps" msgid="4812975097124803873">"Rozšířená nastavení"</string>
    <string name="configure_apps" msgid="6685680790825882528">"Konfigurace aplikací"</string>
    <string name="unknown_app" msgid="5275921288718717656">"Neznámá aplikace"</string>
    <string name="choose_profile" msgid="8229363046053568878">"Vyberte profil"</string>
    <string name="app_permissions" msgid="4148222031991883874">"Oprávnění aplikací"</string>
    <string name="app_permissions_summary" msgid="2098173899436407221">"U <xliff:g id="COUNT_0">%d</xliff:g> z <xliff:g id="COUNT_1">%d</xliff:g> aplikací povolen rozšířený přístup"</string>
    <string name="app_permissions_group_summary" msgid="2721303391744909000">"Povoleno u <xliff:g id="COUNT_0">%d</xliff:g> z <xliff:g id="COUNT_1">%d</xliff:g> aplikací"</string>
    <string name="tap_to_wake" msgid="7211944147196888807">"Probudit klepnutím"</string>
    <string name="tap_to_wake_summary" msgid="4341387904987585616">"Dvojitým klepnutím kamkoli na obrazovku zařízení probudíte"</string>
    <string name="domain_urls_title" msgid="8762012672312435252">"Odkazy aplikací"</string>
    <string name="domain_urls_summary_none" msgid="2639588015479657864">"Neotevírat podporované odkazy"</string>
    <string name="domain_urls_summary_one" msgid="3704934031930978405">"Otevírat adresy z domény <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="812936714383016364">"Otevírat adresy z domény <xliff:g id="DOMAIN">%s</xliff:g> a související URL"</string>
    <plurals name="domain_urls_apps_summary" formatted="false" msgid="4322996467951692661">
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikace mohou otevírat podporované odkazy</item>
      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> aplikace mohou otevírat podporované odkazy</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikací může otevírat podporované odkazy</item>
      <item quantity="one">Jedna aplikace může otevírat podporované odkazy</item>
    </plurals>
    <string name="app_link_open_always" msgid="2474058700623948148">"Otevírat v této aplikaci"</string>
    <string name="app_link_open_ask" msgid="7800878430190575991">"Pokaždé se zeptat"</string>
    <string name="app_link_open_never" msgid="3407647600352398543">"Neotevírat v této aplikaci"</string>
    <string name="fingerprint_not_recognized" msgid="1739529686957438119">"Nerozpoznáno"</string>
    <string name="default_apps_title" msgid="1854974637597514435">"Výchozí aplikace"</string>
    <string name="assist_and_voice_input_title" msgid="1733165754793221197">"Asistence a hlasové zadávání"</string>
    <string name="default_assist_title" msgid="8868488975409247921">"Asistenční aplikace"</string>
    <string name="default_assist_none" msgid="3709083569608735487">"Žádné"</string>
    <string name="choose_assist_title" msgid="554234448228740980">"Zvolte asistenta"</string>
    <string name="assistant_security_warning_title" msgid="8673079231955467177">"Chcete <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> nastavit jako svého asistenta?"</string>
    <string name="assistant_security_warning" msgid="4881965750615394002">"Aplikace <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> bude moci číst informace o aplikacích používaných v systému, včetně informací, které jsou viditelné na obrazovce nebo přístupné v aplikacích."</string>
    <string name="assistant_security_warning_agree" msgid="7710290206928033908">"Souhlasím"</string>
    <string name="assistant_security_warning_disagree" msgid="877419950830205913">"Nesouhlasím"</string>
    <string name="choose_voice_input_title" msgid="975471367067718019">"Zvolte metodu hlasového zadávání"</string>
    <string name="default_browser_title" msgid="8101772675085814670">"Prohlížeč"</string>
    <string name="default_browser_title_none" msgid="2124785489953628553">"Žádný výchozí prohlížeč"</string>
    <string name="default_phone_title" msgid="282005908059637350">"Aplikace na telefonování"</string>
    <string name="default_app" msgid="6864503001385843060">"(Výchozí)"</string>
    <string name="apps_storage" msgid="4353308027210435513">"Úložiště aplikací"</string>
    <string name="usage_access" msgid="5479504953931038165">"Přístup k údajům o využití"</string>
    <string name="permit_usage_access" msgid="4012876269445832300">"Povolit přístup k údajům o využití"</string>
    <string name="app_usage_preference" msgid="7065701732733134991">"Nastavení využití aplikací"</string>
    <string name="usage_access_description" msgid="1352111094596416795">"Přístup k údajům o využití umožňuje aplikaci sledovat, které ostatní aplikace používáte, jak často je používáte, a také operátora, nastavení jazyka a další podrobnosti."</string>
    <string name="memory_settings_title" msgid="7490541005204254222">"Paměť"</string>
    <string name="memory_details_title" msgid="8542565326053693320">"Podrobnosti o paměti"</string>
    <string name="always_running" msgid="6042448320077429656">"Vždy spuštěno (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="6611250683037700864">"Spuštěno občas (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="348413460168817458">"Spuštěno výjimečně (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="6874803757715963097">"Maximum"</string>
    <string name="memory_avg_use" msgid="7382015389130622870">"Průměr"</string>
    <string name="memory_max_desc" msgid="2861832149718335864">"Maximálně <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="1551240906596518412">"Průměrně <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_use_running_format" msgid="4172488041800743760">"<xliff:g id="MEMORY">%1$s</xliff:g> / <xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="77905604092541454">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="2116416853043103135">"Ignorovat optimalizace"</string>
    <string name="high_power_filter_on" msgid="3862942127137594196">"Povoleno"</string>
    <string name="high_power_on" msgid="148473814103292724">"Ignorování optimalizací výdrže baterie"</string>
    <string name="high_power_off" msgid="221092098425904010">"Není povoleno"</string>
    <string name="high_power_desc" msgid="8412735192889327770">"Optimalizace výdrže baterie nebudou použity. Baterie se může vybíjet rychleji."</string>
    <plurals name="high_power_count" formatted="false" msgid="4343190376439806186">
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikace mají povoleno ignorovat optimalizace využití baterie</item>
      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> aplikace má povoleno ignorovat optimalizace využití baterie</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikací má povoleno ignorovat optimalizace využití baterie</item>
      <item quantity="one">1 aplikace má povoleno ignorovat optimalizace využití baterie</item>
    </plurals>
    <string name="battery_summary" msgid="101415762036784289">"Od posledního úplného nabití bylo využito <xliff:g id="PERCENTAGE">%1$d</xliff:g> %% baterie"</string>
    <string name="no_battery_summary" msgid="3528036835462846814">"Baterie od posledního úplného nabití nebyla využita"</string>
    <string name="app_notification_preferences" msgid="1599319335092722613">"Nastavení aplikace"</string>
    <string name="system_ui_settings" msgid="579824306467081123">"Zobrazit tuner SystemUI"</string>
    <string name="additional_permissions" msgid="6463784193877056080">"Další oprávnění"</string>
    <string name="additional_permissions_more" msgid="3538612272673191451">"Počet: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="usb_use_charging_only" msgid="2625934955897625321">"Pouze nabíjení"</string>
    <string name="usb_use_file_transfers" msgid="479119385461326763">"Přenos souborů (MTP)"</string>
    <string name="usb_use_photo_transfers" msgid="7794775645350330454">"Přenos fotek (PTP)"</string>
    <string name="usb_use_MIDI" msgid="5116404702692483166">"MIDI"</string>
    <string name="usb_use" msgid="3372728031108932425">"Použití USB:"</string>
    <string name="inactive_apps_title" msgid="1317817863508274533">"Neaktivní aplikace"</string>
    <string name="inactive_app_inactive_summary" msgid="6768756967594202411">"Neaktivní. Přepnete klepnutím."</string>
    <string name="inactive_app_active_summary" msgid="4512911571954375968">"Aktivní. Přepnete klepnutím."</string>
    <string name="assist_access_context_title" msgid="2269032346698890257">"Použití textu z obrazovky"</string>
    <string name="assist_access_context_summary" msgid="1991421283142279560">"Asistenční aplikace bude mít přístup k obsahu obrazovky v textové podobě"</string>
    <string name="assist_access_screenshot_title" msgid="4034721336291215819">"Použití snímku obrazovky"</string>
    <string name="assist_access_screenshot_summary" msgid="6761636689013259901">"Asistenční aplikace bude mít přístup k obrazu na obrazovce"</string>
    <string name="assist_footer" msgid="1982791172085896864">"Asistenční aplikace vám může pomoci na základě informací na zobrazené obrazovce. Některé aplikace podporují Launcher i hlasový vstup a nabízejí integrovanou asistenci."</string>
    <string name="average_memory_use" msgid="829566450150198512">"Průměrné využití paměti"</string>
    <string name="maximum_memory_use" msgid="7493720799710132496">"Maximální využití paměti"</string>
    <string name="memory_usage" msgid="1781358557214390033">"Využití paměti"</string>
    <string name="app_list_memory_use" msgid="6987417883876419338">"Využití aplikací"</string>
    <string name="memory_details" msgid="5943436005716991782">"Podrobnosti"</string>
    <string name="memory_use_summary" msgid="5608257211903075754">"Za poslední 3 hodiny bylo v průměru využito <xliff:g id="SIZE">%1$s</xliff:g> paměti."</string>
    <string name="no_memory_use_summary" msgid="2016900536806235588">"Za poslední 3 hodiny nebyla využita žádná paměť."</string>
    <string name="sort_avg_use" msgid="3998036180505143129">"Řadit podle prům. využití"</string>
    <string name="sort_max_use" msgid="4629247978290075124">"Řadit podle max. využití"</string>
    <string name="memory_performance" msgid="5661005192284103281">"Výkon"</string>
    <string name="total_memory" msgid="2017287600738630165">"Celková paměť"</string>
    <string name="average_used" msgid="5338339266517245782">"Průměrně použito (%)"</string>
    <string name="free_memory" msgid="4003936141603549746">"Volná"</string>
    <string name="memory_usage_apps" msgid="5650192998273294098">"Paměť používaná aplikacemi"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="6089210945574265774">
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikace použily paměť během posledních <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="many"><xliff:g id="COUNT">%1$d</xliff:g> aplikace použilo paměť během posledních <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikací použilo paměť během posledních <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="one">1 aplikace použila paměť během posledních <xliff:g id="DURATION_0">%2$s</xliff:g></item>
    </plurals>
    <string name="running_frequency" msgid="6622624669948277693">"Frekvence"</string>
    <string name="memory_maximum_usage" msgid="6513785462055278341">"Maximální využití"</string>
    <string name="no_data_usage" msgid="9131454024293628063">"Nebyla využita žádná data"</string>
    <string name="zen_access_warning_dialog_title" msgid="1198189958031157142">"Povolit aplikaci <xliff:g id="APP">%1$s</xliff:g> přístup k režimu Nerušit?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="4015885767653010873">"Aplikace bude moci zapínat a vypínat režim Nerušit a měnit související nastavení."</string>
    <string name="ignore_optimizations_on" msgid="2417358456267927315">"Povolit"</string>
    <string name="ignore_optimizations_off" msgid="9069942099715006633">"Nepovolovat"</string>
    <string name="ignore_optimizations_on_desc" msgid="2321398930330555815">"Baterie se může vybíjet rychleji"</string>
    <string name="ignore_optimizations_off_desc" msgid="5255731062045426544">"Doporučeno k zajištění delší výdrže baterie"</string>
    <string name="ignore_optimizations_title" msgid="2829637961185027768">"Chcete aplikaci <xliff:g id="APP">%s</xliff:g> povolit ignorování optimalizace využití baterie?"</string>
    <string name="app_list_preference_none" msgid="108006867520327904">"Žádné"</string>
    <string name="work_profile_usage_access_warning" msgid="8870622842216566692">"Vypnutí přístupu k informacím o využití pro tuto aplikaci nebrání vašemu správci v měření využití dat aplikacemi ve vašem pracovním profilu."</string>
    <string name="accessibility_lock_screen_progress" msgid="2408292742980383166">"Použité znaky: <xliff:g id="COUNT_0">%1$d</xliff:g> z <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="draw_overlay_title" msgid="4003905926278954971">"Aplikace, kt. se smí vykreslit přes jiné apl."</string>
    <string name="draw_overlay" msgid="9078696044299199938">"Vykreslení přes další aplikace"</string>
    <string name="system_alert_window_settings" msgid="1757821151143694951">"Vykreslení přes další aplikace"</string>
    <string name="system_alert_window_apps_title" msgid="7005760279028569491">"Aplikace"</string>
    <string name="system_alert_window_access_title" msgid="8811695381437304132">"Vykreslení přes další aplikace"</string>
    <string name="permit_draw_overlay" msgid="6606018549732046201">"Povolit vykreslení přes další aplikace"</string>
    <string name="app_overlay_permission_preference" msgid="8355410276571387439">"Oprávnění k vykreslení aplikace navrchu"</string>
    <string name="allow_overlay_description" msgid="7895191337585827691">"Toto oprávnění aplikaci umožňuje zobrazovat se nad jinými aplikacemi, které používáte, a zasahovat do vašeho používání rozhraní jiných aplikací nebo měnit zobrazovaný obsah v jiných aplikacích."</string>
    <string name="keywords_system_alert_window" msgid="8579673659566564926">"vykreslení dialogového okna s upozorněním systému nad jinými aplikacemi"</string>
    <string name="overlay_settings" msgid="222062091489691363">"Vykreslení přes další aplikace"</string>
    <string name="system_alert_window_summary" msgid="4268867238063922290">"Vykreslení přes další aplikace: povoleno u <xliff:g id="COUNT_0">%d</xliff:g> z <xliff:g id="COUNT_1">%d</xliff:g> aplikací"</string>
    <string name="filter_overlay_apps" msgid="6965969283342557573">"Aplikace s oprávněním"</string>
    <string name="system_alert_window_on" msgid="2939489395109048888">"Ano"</string>
    <string name="system_alert_window_off" msgid="6189115687233061992">"Ne"</string>
    <string name="write_settings" msgid="5056260857636128887">"Zápis nastavení systému"</string>
    <string name="keywords_write_settings" msgid="6415597272561105138">"zápis a změna nastavení systému"</string>
    <string name="write_settings_summary" msgid="6501614872574643980">"Čtení nebo zápis nastavení systému: povoleno u <xliff:g id="COUNT_0">%d</xliff:g> z <xliff:g id="COUNT_1">%d</xliff:g> aplikací"</string>
    <string name="filter_write_settings_apps" msgid="5389151171779460004">"Smí zapisovat nastavení systému"</string>
    <string name="write_settings_title" msgid="6706688627484679737">"Smí zapisovat nastavení systému"</string>
    <string name="write_system_settings" msgid="3741717172510029969">"Zápis nastavení systému"</string>
    <string name="write_settings_preference" msgid="2198494932312730862">"Oprávnění aplikace k zápisu nastavení systému"</string>
    <string name="permit_write_settings" msgid="5754070436853714432">"Povolit zápis nastavení systému"</string>
    <string name="write_settings_description" msgid="5124206705845320852">"Toto oprávnění umožňuje aplikaci číst nebo zapisovat nastavení systému."</string>
    <string name="write_settings_on" msgid="8230580416068832239">"Ano"</string>
    <string name="write_settings_off" msgid="5156104383386336233">"Ne"</string>
</resources>
