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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="1999566976857398962">"Ano"</string>
    <string name="no" msgid="5541738710521607130">"Ne"</string>
    <string name="create" msgid="986997212165228751">"Vytvořit"</string>
    <string name="allow" msgid="3763244945363657722">"Povolit"</string>
    <string name="deny" msgid="7326117222944479942">"Odmítnout"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Zapnout"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Neznámé"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Klepnutím zobrazíte informace."</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Jste # krok od toho, abyste se stali vývojářem.}few{Jste # kroky od toho, abyste se stali vývojářem.}many{Jste # kroku od toho, abyste se stali vývojářem.}other{Jste # kroků od toho, abyste se stali vývojářem.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Voilà! Stal se z vás vývojář."</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Není potřeba, již jste vývojář."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Nejprve prosím aktivujte možnosti pro vývojáře."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Systém"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"V provozu"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Mimo provoz"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Bezdrátový modul je vypnut"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Bez roamingu"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Odpojeno"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Připojování"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Připojeno"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Pozastaveno"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Neznámé"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Náhled"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Zmenšit"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Zvětšit"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Vždy"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Když zařízení složíte, přední displej se zapne"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Pouze hry, videa a další"</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"U aplikací, které obrazovce brání v přechodu do režimu nečinnosti, se zapne přední displej"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Nikdy"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Když zařízení složíte, přední displej se uzamkne"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Automaticky otáčet obrazovku"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Rozpoznání obličeje používá přední fotoaparát ke zvýšení přesnosti automatického otáčení. Fotky se neukládají ani neodesílají do Googlu."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"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="8122823110652921674">"Viditelné pro všechny okolní zařízení Bluetooth"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Neviditelné pro ostatní zařízení Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Viditelné pouze pro spárovaná zařízení"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Zařízení Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Název zařízení"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Přejmenovat toto zařízení"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Přejmenovat"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Odpojit zařízení?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Spárovat nové zařízení"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Spárovat pravé ucho"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Spárovat levé ucho"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Spárovat druhé ucho"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Levé naslouchátko je připojeno.\n\nPokud chcete spárovat pravé, ujistěte se, zda je zapnuté a připravené k párování."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Pravé naslouchátko je připojeno.\n\nPokud chcete spárovat levé, ujistěte se, zda je zapnuté a připravené k párování."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Spárovat pravé ucho"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Spárovat levé ucho"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Pro všechna dostupná naslouchátka"</string>
    <string name="bluetooth_device_controls_title" msgid="1895676556354697234">"Nastavení naslouchátek"</string>
    <string name="bluetooth_device_controls_summary" msgid="8115767735418425663">"Zkratka, kompatibilita s naslouchátky"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Pro toto zařízení"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Výstup zvuku"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Informace o zvukovém výstupu"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Směrování zvuků do naslouchátek nebo reproduktoru telefonu"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Související"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Vyzvánění a budíky"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Zvuk během hovorů"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Média"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Oznámení a jiné systémové zvuky"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Ve výchozím nastavení určují zvukový výstup jednotlivé aplikace"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Nepojmenované zařízení Bluetooth"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Hledání"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"V okolí nejsou žádná zařízení Bluetooth."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Žádost o spárování zařízení Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Žádost o spárování"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Klepnutím spárujete se zařízením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Rozhraní Bluetooth je vypnuté"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Zapnete klepnutím"</string>
    <string name="device_picker" msgid="2427027896389445414">"Vybrat zařízení Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnout Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> chce vypnout Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Aplikace chce zapnout Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Aplikace chce vypnout Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Zapínání Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Vypínání rozhraní Bluetooth…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Požadavek na připojení zařízení Bluetooth"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Požadavek na přístup k telefonnímu seznamu"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Požadavek na přístup ke zprávám"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Viditelné pro ostatní zařízení jako „<xliff:g id="DEVICE_NAME">^1</xliff:g>“"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Pokud se chcete připojit k ostatním zařízením, zapněte Bluetooth."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Vaše zařízení"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Spárovat nové zařízení"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Vypnout hardwarové snížení zátěže Bluetooth (A2DP)"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Vypnout snižování zatížení zvukového hardwaru Bluetooth LE"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Restartovat zařízení?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Ke změně nastavení je nutné restartovat zařízení."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Restartovat"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Zrušit"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Deaktivovat Bluetooth LE audio"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Vypne funkci zvuku přes Bluetooth LE, pokud zařízení podporuje hardwarové zvukové funkce LE."</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Zobrazit přepínač LE Audio v Podrobnostech o zařízení"</string>
    <string name="bluetooth_enable_leaudio_allow_list" msgid="1692999156437357534">"Zapnout seznam povolených zařízení Bluetooth LE Audio"</string>
    <string name="bluetooth_enable_leaudio_allow_list_summary" msgid="725601205276008525">"Povolit funkci seznamu povolených zařízení Bluetooth LE Audio."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Mediální zařízení"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Volání na zařízení"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Ostatní zařízení"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Uložená zařízení"</string>
    <string name="connected_device_fast_pair_device_title" msgid="543124539265592392">"Přidružení k účtu"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Za účelem spárování se Bluetooth zapne"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Předvolby připojení"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Dříve připojeno"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth je zapnuto"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Zobrazit vše"</string>
    <string name="connected_device_fast_pair_device_see_all" msgid="4898279230458128620">"Zobrazit vše"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Dotykové pero"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Stisknutí tlačítka dotykového pera"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (pracovní profil)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Psát do textových polí"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Ignorovat všechna stisknutí tlačítka na dotykovém peru"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Dotykové pero"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Datum a čas"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy server"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Vymazat"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Port proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Nepoužívat proxy server pro"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Obnovit výchozí nastavení"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Hotovo"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Název hostitele proxy serveru"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Upozornění"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Zadaný název hostitele není platný."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"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="4250295137005082992">"Vyplňte pole portu."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Pokud je pole hostitel prázdné, musí být prázdné i pole port."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Zadaný port není platný."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Proxy server protokolu HTTP může používat prohlížeč, ale nesmí jej používat další aplikace."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"Adresa URL PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Ping názvu hostitele (www.google.com) IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Test klienta HTTP:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Spustit test Ping"</string>
    <string name="skip_label" msgid="6380034601349015895">"Přeskočit"</string>
    <string name="next_label" msgid="1248293387735652187">"Další"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Jazyky"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Pořadí preferovaných jazyků"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Jazyk systému"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Odstranit"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Přidat jazyk"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Jazyk"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Preferovaný jazyk"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Jazyky aplikací"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Nastavení jazyka pro jednotlivé aplikace"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Jazyk aplikace"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Navrhované jazyky"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Všechny jazyky"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Jazyk systému"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Výchozí nastavení systému"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"V Nastavení nelze vybrat jazyk pro tuto aplikaci."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Jazyky nemusí odpovídat jazykům dostupným v aplikaci. Toto nastavení mohou podporovat jen některé aplikace."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Nastavení jazyka pro jednotlivé aplikace."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Z preferovaných jazyků použije systém, aplikace a weby první podporovaný jazyk."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Pokud chcete zvolit jazyk jednotlivých aplikací, přejděte do nastavení jazyka aplikace."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Další informace o jazycích aplikací"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Změnit jazyk systému na %s ?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"Přidat jazyk %s k preferovaným jazykům?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"Aplikace a weby budou vědět, že také preferujete tento jazyk."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Změní se nastavení vašeho zařízení a regionální preference."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Změnit"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s není k dispozici"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Tento jazyk nelze použít jako jazyk systému, ale dali jste aplikacím a webům vědět, že ho preferujete."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Regionální preference"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Nastavení předvoleb jednotek a čísel"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Sdělte aplikacím své regionální preference, aby vám mohly přizpůsobit prostředí."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Aplikace vaše regionální preference použijí všude, kde je to možné."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Teplota"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"První den týdne"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Předvolby číslic"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Použít výchozí"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Stupně Celsia (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Stupně Fahrenheita (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"neděle"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"pondělí"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"úterý"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"středa"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"čtvrtek"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"pátek"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"sobota"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Pokud aplikace regionální preference nepodporuje, použije výchozí nastavení národního prostředí."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Další informace o jazykových preferencích"</string>
    <string name="category_title_terms_of_address" msgid="4309422700380895278">"Další předvolby"</string>
    <string name="terms_of_address_title" msgid="4064593634733842458">"Způsob oslovení"</string>
    <string name="terms_of_address_summary" msgid="6136134336560679144">"Jak chcete být oslovováni"</string>
    <string name="terms_of_address_intro_title" msgid="6149691509414243483">"Aplikace vás může oslovovat tak, jak jí určíte."</string>
    <string name="terms_of_address_not_specified" msgid="4439257779351251973">"Neurčeno"</string>
    <string name="terms_of_address_feminine" msgid="1743479869695539283">"Žena"</string>
    <string name="terms_of_address_masculine" msgid="983106046135098856">"Muž"</string>
    <string name="terms_of_address_neutral" msgid="5475414185543112478">"Neutrální"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Odstranit vybraný jazyk?}few{Odstranit vybrané jazyky?}many{Odstranit vybrané jazyky?}other{Odstranit vybrané jazyky?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Text se bude zobrazovat v jiném jazyce."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Nelze odstranit všechny jazyky"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Ponechte alespoň jeden preferovaný jazyk"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Není k dispozici jako systémový jazyk"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Přesunout nahoru"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Přesunout dolů"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Přesunout na začátek"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Přesunout na konec"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Odstranit jazyk"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Vybrat aktivitu"</string>
    <string name="cancel" msgid="5780102414089664898">"Zrušit"</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Zapomenout"</string>
    <string name="save" msgid="3125033126936493822">"Uložit"</string>
    <string name="done" msgid="7497982645646431310">"Hotovo"</string>
    <string name="apply" msgid="7834684883190163536">"Použít"</string>
    <string name="share" msgid="8502235338607613795">"Sdílet"</string>
    <string name="add" msgid="8335206931421683426">"Přidat"</string>
    <string name="remove" msgid="1028414219245072102">"Odstranit"</string>
    <string name="settings_label" msgid="943294133671632976">"Nastavení"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Nastavení"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Zástupce nastavení"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Režim Letadlo"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Bezdrátová připojení a sítě"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Používat datové služby při roamingu"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Používat datové služby při roamingu"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Mohou vám být účtovány poplatky za roaming."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Nastavovat čas automaticky"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Nastavovat automaticky"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Když je tento přepínač zapnutý, bude se k nastavení časového pásma používat poloha"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Používat výchozí nastavení jazyka"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Používat 24hodinový formát"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Čas"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Formát času"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Časové pásmo"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Volba časového pásma"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Datum"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Vyhledat oblast"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Region"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Vyberte posun od UTC"</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer_first_sentence" msgid="1326664252091302458">"Použití: <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="SECOND_SENTENCE">%2$s</xliff:g>"</string>
    <string name="zone_info_footer_second_sentence" msgid="6472889173541729110">"<xliff:g id="DST_TIME_TYPE">%1$s</xliff:g> začíná <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Používá <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Nepoužívá letní čas."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Letní čas"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standardní čas"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Vybrat podle oblasti"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Vybrat podle posunu od UTC"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Interval uzamčení obrazovky"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po vypršení časového limitu"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Okamžitě po vypršení časového limitu, pokud odemknutí není udržováno funkcí <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po vypršení časového limitu, pokud odemknutí není udržováno funkcí <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Text na obrazovce uzamčení"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Bez textu"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Např. Tomův Android."</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Poloha"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Používat polohu"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Vypnuto"</string>
    <string name="location_settings_summary_location_on" msgid="4273299717586679786">"{count,plural, =1{Zapnuto – # aplikace má přístup k poloze}few{Zapnuto – # aplikací má přístup k poloze}many{Zapnuto – # aplikací má přístup k poloze}other{Zapnuto – # aplikací má přístup k poloze}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Načítání…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Aplikace s oprávněním pro přístup k zařízením v okolí mohou zjišťovat relativní polohu připojených zařízení."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Přístup aplikací a služeb k poloze je vypnutý. Poloha zařízení může být přesto odesílána záchranářům, když vytočíte číslo tísňového volání nebo na něj pošlete SMS."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Přečtěte si další informace o nastavení polohy."</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Účty"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Zabezpečení"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Šifrování a pověření"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Obrazovka uzamčení"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Co zobrazovat"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Nedostupné"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Stav zabezpečení"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Zámek obrazovky, Najdi moje zařízení, zabezpečení aplikací"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Zabezpečení a ochrana soukromí"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Zabezpečení aplikací, zámek zařízení, oprávnění"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Obličej přidán"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Nutné nastavení"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Odemknutí obličejem"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Odemknutí obličejem pro práci"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Jak nastavit odemknutí obličejem"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Nastavte odemknutí obličejem"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Ověření pomocí obličeje"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Začít"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Pokud je vypnuto odemknutí obličejem v režimu přístupnosti, některé kroky nastavení nemusí s aplikací TalkBack fungovat správně."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Zpět"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Pokračovat v nastavení"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Použít nastavení přístupnosti"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Zrušit"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Ne, děkuji"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Souhlasím"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Další"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Odemykání pomocí obličeje"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Povolit odemknutí obličejem"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Ověření pomocí obličeje"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Odemykejte telefon a schvalujte nákupy pomocí obličeje.\n\nPoznámka: Obličej nelze použít k odemykání tohoto zařízení. Další informace vám poskytne administrátor vaší organizace."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Odemykejte telefon, autorizujte nákupy a přihlašujte se do aplikací."</string>
    <string name="security_settings_face_enroll_introduction_info_title" msgid="7120796118179406944"></string>
    <string name="security_settings_face_enroll_introduction_info_glasses" msgid="2733870453868907471"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_glasses" msgid="6303917184145586880"></string>
    <string name="security_settings_face_enroll_introduction_how_title" msgid="3680193263037835600"></string>
    <string name="security_settings_face_enroll_introduction_control_title" msgid="4536951089583821051"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_title" msgid="5892729331412694759"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Umístěte obličej do středu kruhu"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Přeskočit"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Přidali jste maximální počet obličejů"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Další obličeje přidat nelze"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Konfigurace nebyla dokončena"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Při registraci obličeje bylo dosaženo časového limitu. Zkuste to znovu."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Registrace obličeje se nezdařila."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Vše je nastaveno."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Hotovo"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Vylepšete výkon odemknutí obličejem"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Nastavte odemknutí obličejem znovu"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Nastavte odemknutí obličejem znovu"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Vylepšení zabezpečení a výkonu"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Nastavte odemknutí obličejem"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Pokud chcete odemknutí obličejem nastavit znovu, smažte stávající model obličeje.\n\nModel obličeje bude trvale a bezpečně smazán.\n\nPo smazání budete k odemykání telefonu a ověřování v aplikacích používat PIN, gesto nebo heslo."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Pokud chcete odemknutí obličejem nastavit znovu, smažte stávající model obličeje.\n\nModel obličeje bude trvale a bezpečně smazán.\n\nPo smazání budete k odemykání telefonu a ověřování v aplikacích používat otisk prstu, PIN, gesto nebo heslo."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Pomocí odemknutí obličejem"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Při odemykání obličejem:"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Požadovat otevřené oči"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"K odemknutí telefonu musíte mít otevřené oči"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Vždy vyžadovat potvrzení"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Při odemykání obličejem v aplikacích vždy vyžadovat potvrzení."</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Smazat model obličeje"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Nastavit odemknutí obličejem"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Smazat model obličeje?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Model obličeje bude trvale a bezpečně smazán.\n\nPo smazání budete k odemykání telefonu a ověřování v aplikacích používat PIN, gesto nebo heslo."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Model obličeje bude trvale a bezpečně smazán.\n\nPo smazání budete k odemknutí telefonu potřebovat PIN, gesto nebo heslo."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Model obličeje bude trvale a bezpečně smazán.\n\nPo smazání budete k odemykání telefonu a ověřování v aplikacích používat otisk prstu, PIN, gesto nebo heslo."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Model obličeje bude trvale a bezpečně smazán.\n\nPo smazání budete k odemknutí telefonu potřebovat PIN, gesto nebo heslo."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Odemykejte telefon pomocí obličeje"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Otisk prstu"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Otisk prstu"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Při odemykání otiskem prstu"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Otisk prstu pro práci"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Přidat otisk prstu"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Otisk byl přidán}few{Byly přidány # otisky}many{Bylo přidáno # otisku}other{Bylo přidáno # otisků}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Nutné nastavení"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Nastavení otisku prstu"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Povolit odemk. otiskem prstu"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Použití otisku prstu"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Další informace o odemknutí otiskem prstu"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Vše máte ve svých rukou"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Vy a dítě máte vše pod kontrolou"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Upozornění"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Odemykejte telefon a schvalujte nákupy otiskem prstu.\n\nPoznámka: Otisk prstu nelze použít k odemykání tohoto zařízení. Další informace vám poskytne administrátor vaší organizace."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Zrušit"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Ne, díky"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Souhlasím"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Přeskočit zadání otisku prstu?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Nastavení otisku prstu trvá jen minutu nebo dvě. Pokud tento krok přeskočíte, můžete otisk prstu přidat později v nastavení."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Když uvidíte tuto ikonu, proveďte ověření pomocí otisku prstu, například při přihlašování do aplikací nebo schvalování nákupů"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Upozornění"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Jak to funguje"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Funkce odemknutí otiskem prstu používá unikátní model vašeho otisku prstu k ověření identity. Model otisku prstu se vytváří na základě snímků otisku prstu z různých úhlů."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Odemknutí otiskem prstu vytváří jedinečný model otisku prstu dítěte, podle kterého ho při ověření poznáme. Model otisku prstu vytvoříme při nastavování na základě snímků otisku prstu z různých úhlů."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Nejlepších výsledků dosáhnete s ochranou displeje, která má certifikát Made for Google. S ostatními ochranami displeje nemusí otisk prstu fungovat."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Nejlepších výsledků dosáhnete s ochranou displeje, která má certifikát Made for Google. S ostatními ochranami displeje nemusí otisk prstu dítěte fungovat."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Odemknutí pomocí hodinek"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Pokud budete mít při odemykání obličejem zakrytou tvář nebo bude vaše okolí tmavé, telefon bude žádat o nasnímání otisku prstu.\n\nPokud nerozpozná váš obličej nebo otisk, můžete ho odemknout hodinkami."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Telefon můžete odemknout hodinkami, pokud nerozpozná váš otisk prstu."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Telefon můžete odemknout hodinkami, pokud nerozpozná váš obličej."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Použít otisk prstu nebo hodinky k"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Použít obličej nebo hodinky k"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Použít obličej, otisk prstu nebo hodinky k"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Použít hodinky k"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Pomocí obličeje nebo hodinek"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Pomocí otisku prstu nebo hodinek"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Pomocí obličeje, otisku prstu nebo hodinek"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Pomocí hodinek"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Nejdřív nastavte odemknutí obličejem nebo otiskem prstu"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Pokud nerozpozná váš obličej nebo otisk prstu, můžete telefon odemknout hodinkami"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Nejdřív nastavte odemknutí otiskem prstu"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Telefon můžete odemknout hodinkami, pokud nerozpozná váš otisk prstu"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Nejdřív nastavte odemknutí obličejem"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Telefon můžete odemknout hodinkami, pokud nerozpozná váš obličej"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Nastavit"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Otisk prstu a hodinky <xliff:g id="WATCH">%s</xliff:g> byly přidány"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Otisky prstů a hodinky <xliff:g id="WATCH">%s</xliff:g> byly přidány"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Obličej a hodinky <xliff:g id="WATCH">%s</xliff:g> byly přidány"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Obličej, otisk prstu a hodinky <xliff:g id="WATCH">%s</xliff:g> byly přidány"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Obličej, otisky prstů a hodinky <xliff:g id="WATCH">%s</xliff:g> byly přidány"</string>
    <string name="security_settings_remoteauth_preference_title" msgid="8319680328086089533">"Odemknutí pomocí nástroje Remote Authenticator"</string>
    <string name="security_settings_remoteauth_preference_summary" msgid="1507004469316635196">"Hodinky byly přidány"</string>
    <string name="security_settings_remoteauth_enroll_introduction_title" msgid="2151004795778999671">"Nastavení hodinek"</string>
    <string name="security_settings_remoteauth_enroll_introduction_message" msgid="8737276885766036074">"Odemknutí pomocí hodinek je další pohodlný způsob, jak tento telefon odemknout, například když máte mokré prsty nebo když nerozpozná váš obličej.\n\nPomocí hodinek můžete tento telefon odemknout, když:"</string>
    <string name="security_settings_remoteauth_enroll_introduction_disagree" msgid="7639258097401796028">"Teď ne"</string>
    <string name="security_settings_remoteauth_enroll_introduction_agree" msgid="5271119227172049339">"Pokračovat"</string>
    <string name="security_settings_remoteauth_enroll_introduction_more" msgid="1644105894631257595">"Další možnosti"</string>
    <string name="security_settings_remoteauth_enroll_introduction_how_title" msgid="6604152528267830349">"Jak to funguje"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open" msgid="8570511335628725116">"Hodinky musí být odemknuté, nasazené na ruce a v dosahu telefonu. Nasazené hodinky nebudete muset znovu odemykat."</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications" msgid="4298855831154039694">"Když se telefon odemkne, obdržíte na hodinky oznámení. Pokud byl odemknutý, aniž byste to chtěli, klepnutím na oznámení ho můžete znovu zamknout."</string>
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title" msgid="7974976673323638524">"Vše máte ve svých rukou"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch" msgid="1888318677088986801">"Hodinky můžete z odemykání pomocí hodinek kdykoli odstranit v Nastavení"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification" msgid="1597397399097952974">"Klepněte na oznámení"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up" msgid="2129230804324634653">"Přejeďte po obrazovce uzamčení nahoru"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_title" msgid="313016997943607675">"Vyberte své hodinky"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading" msgid="8227585438932911013">"Dostupné hodinky"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_disagree" msgid="1670201454188049863">"Zrušit"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_agree" msgid="7048336252635730908">"Potvrdit"</string>
    <string name="security_settings_remoteauth_enroll_finish_title" msgid="3807372930755413112">"A je to."</string>
    <string name="security_settings_remoteauth_enroll_finish_description" msgid="4876209907275244653">"Když po obrazovce uzamčení přejedete prstem nahoru nebo klepnete na oznámení, můžete nyní tento telefon odemknout pomocí hodinek"</string>
    <string name="security_settings_remoteauth_enroll_finish_btn_next" msgid="8072138423143889592">"Hotovo"</string>
    <string name="security_settings_remoteauth_settings_title" msgid="1564912618737165129">"Odemknutí pomocí hodinek"</string>
    <string name="security_settings_remoteauth_settings_description" msgid="2758239650119457964">"Když po obrazovce uzamčení přejedete prstem nahoru nebo klepnete na oznámení, můžete tento telefon odemknout pomocí hodinek"</string>
    <string name="security_settings_remoteauth_settings_info_footer" msgid="795894033901478120">"K odemknutí pomocí hodinek musíte být hodinky odemknuté, nasazené na ruce, v dosahu a připojené k tomuto telefonu. V případě přerušení připojení budete odemknutí pomocí hodinek moci používat až poté, co telefon odemknete.\n\nMějte na paměti:\nV jednu chvíli lze mít nastavené jen jedny hodinky. Pokud chcete přidat další hodinky, nejdříve odstraňte ty aktuální."</string>
    <string name="security_settings_remoteauth_settings_learn_more" msgid="5653556124819260050">"Další informace o odemknutí pomocí hodinek"</string>
    <string name="security_settings_remoteauth_settings_register_new_authenticator" msgid="9191331738306527887">"Přidat hodinky"</string>
    <string name="security_settings_remoteauth_settings_remove_device" msgid="2436226120578851282">"Odstranit hodinky"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Odemknutí pomocí otisku prstu nebo obličeje"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Odemknutí obličejem a otiskem prstu pro práci"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Nutné nastavení"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Byl přidán obličej a otisky prstů"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Byl přidán obličej a otisk prstu"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Když nastavíte odemknutí obličejem a otiskem prstu, telefon bude žádat o nasnímání otisku prstu v případě, že budete mít zakrytou tvář nebo vaše okolí bude tmavé"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Způsoby odemykání"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Pomocí obličeje nebo otisku prstu můžete:"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Odemykat telefon"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Ověřovat v aplikacích svou totožnost"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Pomocí obličeje"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Pomocí otisku prstu"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Pomocí obličeje nebo otisku prstu"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"OK"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Odemknutí obličejem se nedaří nastavit"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"K nastavení odemknutí obličejem ukončete rozdělenou obrazovku"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Otisk prstu se nepodařilo nastavit"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"K nastavení odemknutí otiskem prstu ukončete rozdělenou obrazovku"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"OK"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Přeskočit zámek obrazovky?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Přeskočit"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Zpět"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Přeskočit"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Zrušit"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Dotkněte se senzoru"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Dotkněte se vypínače, aniž byste ho stiskli"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Jak nastavit otisk prstu"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Je na zadní straně telefonu. Použijte ukazováček."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Snímač otisků prstů je na displeji. Otisk prstu nasnímáte na další obrazovce."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Začít"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Pohybujte prstem po obrazovce a najděte snímač otisků. Podržte na něm prst přitisknutý."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustrace se zařízením a polohou senzoru otisků prstů"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Název"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Zkusit znovu"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Smazat"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Dotkněte se senzoru"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Položte prst na senzor. Zvedněte ho, až zařízení zavibruje."</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Držte prst na snímači, dokud neucítíte vibraci"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Aniž byste stiskli tlačítko, nechte prst položený na snímači, dokud neucítíte zavibrování.\n\nPokaždé prst lehce posuňte. Bude tak zachycena větší část otisku prstu."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Podržte prst přitisknutý na snímači otisků"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Zvedněte prst a dotkněte se znovu"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Ještě jednou"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Sledujte ikonu otisku prstu"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Prst opakovaně zvedejte a pokládejte, aby se zaznamenaly různé části otisku."</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Podržte snímač pokaždé, když se ikona otisku prstu pohne. Bude tak zachycena větší část otisku prstu."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Umístěte špičku prstu na snímač"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Přiložte levou stranu prstu"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Přiložte pravou stranu prstu"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Umístěte na snímač bříško prstu"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Umístěte špičku prstu na snímač"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Přiložte na snímač levou stranu prstu"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Nakonec na snímač umístěte pravou stranu prstu"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Umístěte boční stranu prstu na snímač a podržte ho, poté ho „překulte“ na druhou stranu"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Bude tak zachycena větší část otisku prstu"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Registrace otisku prstu: <xliff:g id="PERCENTAGE">%d</xliff:g> procent"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Zaregistrováno <xliff:g id="PERCENTAGE">%d</xliff:g> procent"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Registrace otisku prstu: <xliff:g id="PERCENTAGE">%d</xliff:g> procent"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Otisk byl přidán"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Odemknout dotykem kdykoli"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Když se dotknete snímače, zařízení se odemkne, i když je obrazovka vypnutá. Nezamýšlené odemknutí je tak pravděpodobnější."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Obrazovka, odemknutí"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Později"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Zvedněte prst a dotkněte se znovu"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Umístěte boční stranu prstu na snímač a podržte ho, poté ho „překulte“ na druhou stranu"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Přeskočit nastavení otisku prstu?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Jako jeden ze způsobů odemknutí telefonu jste se rozhodli používat otisk prstu. Pokud nastavení přeskočíte, bude třeba jej dokončit později. Nastavení trvá jen chviličku."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Přeskočit nastavení pro <xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Přeskočit nastavení kódu PIN?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Přeskočit nastavení PINu a obličeje?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Přeskočit nastavení PINu a otisku?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Přeskočit nastavení PINu, obličeje a otisku?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Přeskočit nastavení hesla?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Přeskočit nastavení hesla a obličeje?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Přeskočit nastavení hesla a otisku?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Přeskočit nastavení hesla, obličeje a otisku?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Přeskočit nastavení gesta?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Přeskočit nastavení gesta a obličeje?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Přeskočit nastavení gesta a otisku?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Přeskočit nastavení gesta, obličeje a otisku?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Nastavit zámek obrazovky"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Hotovo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Jejda, to není senzor."</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Dotkněte se senzoru na zadní straně telefonu. Použijte ukazováček."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Nastavení otisku prstu se nepodařilo dokončit"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Zkuste to znovu nebo otisk prstu nastavte později v Nastavení."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Zkuste to znovu nebo otisk prstu nastavte později."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Časový limit nastavení otisku prstu vypršel"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Otisk prstu můžete nastavit později v Nastavení."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Něco se pokazilo. Otisk prstu můžete nastavit později v Nastavení."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Otisk prstu můžete nastavit později."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Něco se pokazilo. Otisk prstu můžete nastavit později."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Přidat další"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Další"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Možnost zámku obrazovky je zakázána. Další informace vám sdělí administrátor vaší organizace."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Otisk prstu můžete i nadále používat k autorizaci nákupů a přístupu k aplikacím."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Prst opakovaně zvedejte a přikládejte na senzor."</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Snímač otisků prstů nelze použít"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Navštivte servis."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Další nastavení zabezpečení"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Zámek pracovního profilu, šifrování a další"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Šifrování, přihlašovací údaje a další"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"zabezpečení, další nastavení zabezpečení, další nastavení, pokročilá nastavení zabezpečení"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Další nastavení ochrany soukromí"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Další zabezpečení a ochrana soukromí"</string>
    <string name="security_header" msgid="961514795852103424">"Zabezpečení"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Ochrana soukromí"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Pracovní profil"</string>
    <string name="private_space_title" msgid="7078627930195569767">"Soukromý prostor"</string>
    <string name="private_space_summary" msgid="8237652417163408001">"Skrýt aplikace v soukromé složce"</string>
    <string name="private_space_one_lock_title" msgid="7306547190751832568">"Odemknout pomocí zámku obrazovky"</string>
    <string name="private_space_hide_title" msgid="1615744426933304644">"Zobrazit soukromý prostor"</string>
    <string name="private_space_category_system" msgid="1286843321867285700">"Systém"</string>
    <string name="private_space_create_title" msgid="47273568884806726">"Vytvořit soukromý prostor"</string>
    <string name="private_space_delete_title" msgid="3075645119800272800">"Smazat soukromý prostor"</string>
    <string name="private_space_created" msgid="2978055968937762232">"Soukromý prostor byl úspěšně vytvořen"</string>
    <string name="private_space_already_exists" msgid="1253034947621867419">"Soukromý prostor už existuje"</string>
    <string name="private_space_create_failed" msgid="4908100791174213808">"Soukromý prostor se nepodařilo vytvořit"</string>
    <string name="private_space_deleted" msgid="7825768516955610897">"Soukromý prostor byl úspěšně smazán"</string>
    <string name="private_space_delete_failed" msgid="8500755484258565011">"Soukromý prostor se nepodařilo vytvořit"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Maximální počet otisků prstů, které lze přidat: <xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Přidali jste maximální počet otisků prstů"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Další otisky prstů nelze přidat"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Smazat otisk <xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Otisk prstu už nebude možné používat k odemknutí pracovního profilu, autorizaci nákupů ani přihlašování do pracovních aplikací."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Šifrování"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Šifrováno"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Nastavení zámku obrazovky"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Kvůli lepší bezpečnosti nastavte v zařízení PIN, gesto nebo heslo."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Nastavit zámek obrazovky"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Nastavte zámek obrazovky"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Kvůli lepší bezpečnosti nastavte v zařízení PIN, gesto nebo heslo."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Zabezpečení telefonu"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Chcete-li odemknout, přidejte otisk prstu"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Zámek obrazovky"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Vyberte zámek obrazovky"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Zvolte nový zámek obrazovky"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Vyberte zámek pro pracovní aplikace"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Vyberte nový pracovní zámek"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Pro ještě lepší zabezpečení si nastavte záložní zámek obrazovky"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Zvolte záložní metodu zámku obrazovky"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Pokud zapomenete zámek obrazovky, administrátor IT ho nemůže resetovat."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Nastavit samostatný pracovní zámek"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Pokud tento zámek zapomenete, požádejte administrátora IT o resetování."</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Možnosti zámku obrazovky"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Možnosti zámku obrazovky"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Automatické potvrzování odemknutí"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Nechte si zařízení odemknout automaticky, když zadáte správný PIN o délce minimálně 6 číslic. Tato možnost je o něco méně bezpečná než potvrzení klepnutím na Enter."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Automaticky potvrzovat správný kód PIN"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Potvrzení kódu PIN klepnutím na Enter je bezpečnější než používání automatického potvrzení"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Pokud chcete zapnout automatické potvrzení, zadejte PIN zařízení"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Pokud chcete vypnout automatické potvrzení, zadejte PIN zařízení"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Zámek obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Zámek pracovního profilu"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Žádný"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Přejetí prstem"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Gesto"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Heslo"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Teď ne"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Aktuální zámek obrazovky"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Gesto • Otisk prstu"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN • Otisk prstu"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Heslo • Otisk prstu"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Pokračovat bez otisku prstu"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Gesto • Obličej"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN • Obličej"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Heslo • Obličej"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Pokračovat bez odemknutí obličejem"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Pokračovat bez otisku prstu nebo obličeje"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Bez zabezpečení"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Přejetí prstem"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Gesto"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Heslo"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Smazat zámek obrazovky?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Odstranit ochranu profilu?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Gesto chrání telefon v případě ztráty nebo odcizení"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Gesto chrání telefon v případě ztráty nebo odcizení.<xliff:g id="EMPTY_LINE">

</xliff:g>Touto akcí také smažete model otisku prstu uložený v zařízení. Otisk prstu nebudete moci používat ani k ověřování v aplikacích."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Gesto chrání telefon v případě ztráty nebo odcizení.<xliff:g id="EMPTY_LINE">

</xliff:g>Bude také trvale a bezpečně smazán model obličeje. K ověření v aplikacích nebudete moci používat obličej."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Gesto chrání telefon v případě ztráty nebo odcizení.<xliff:g id="EMPTY_LINE">

</xliff:g>Touto akcí smažete model otisku prstu uložený v zařízení. Bude také trvale a bezpečně smazán model obličeje. Obličej ani otisk prstu nebudete moci používat ani k ověřování v aplikacích."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"V případě ztráty nebo odcizení telefonu ho PIN chrání."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"PIN chrání telefon v případě ztráty nebo odcizení.<xliff:g id="EMPTY_LINE">

</xliff:g>Touto akcí také vymažete model otisku prstu uložený v zařízení. Otisk prstu nebudete moci používat ani k ověřování v aplikacích."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"PIN chrání telefon v případě ztráty nebo odcizení.<xliff:g id="EMPTY_LINE">

</xliff:g>Bude také trvale a bezpečně smazán model obličeje. K ověření v aplikacích nebudete moci používat obličej."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"PIN chrání telefon v případě ztráty nebo odcizení.<xliff:g id="EMPTY_LINE">

</xliff:g>Touto akcí smažete model otisku prstu uložený v zařízení. Bude také trvale a bezpečně smazán model obličeje. Obličej ani otisk prstu nebudete moci používat ani k ověřování v aplikacích."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Heslo chrání telefon v případě ztráty nebo odcizení"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Heslo chrání telefon v případě ztráty nebo odcizení.<xliff:g id="EMPTY_LINE">

</xliff:g>Touto akcí také smažete model otisku prstu uložený v zařízení. Otisk prstu nebudete moci používat ani k ověřování v aplikacích."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Heslo chrání telefon v případě ztráty nebo odcizení.<xliff:g id="EMPTY_LINE">

</xliff:g>Bude také trvale a bezpečně smazán model obličeje. K ověření v aplikacích nebudete moci používat obličej."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Heslo chrání telefon v případě ztráty nebo odcizení.<xliff:g id="EMPTY_LINE">

</xliff:g>Touto akcí smažete model otisku prstu uložený v zařízení. Bude také trvale a bezpečně smazán model obličeje. Obličej ani otisk prstu nebudete moci používat ani k ověřování v aplikacích."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Bez zámku obrazovky nebudou funkce ochrany zařízení fungovat."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Bez zámku obrazovky nebudou fungovat funkce ochrany zařízení.<xliff:g id="EMPTY_LINE">

</xliff:g>Touto akcí také smažete model otisku prstu uložený v zařízení. Otisk prstu nebudete moci používat ani k ověřování v aplikacích."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Bez zámku obrazovky nebudou fungovat funkce ochrany zařízení.<xliff:g id="EMPTY_LINE">

</xliff:g>Bude také trvale a bezpečně smazán model obličeje. K ověření v aplikacích nebudete moci používat obličej."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Bez zámku obrazovky nebudou fungovat funkce ochrany zařízení.<xliff:g id="EMPTY_LINE">

</xliff:g>Touto akcí smažete model otisku prstu uložený v zařízení. Bude také trvale a bezpečně smazán model obličeje. Obličej ani otisk prstu nebudete moci používat ani k ověřování v aplikacích."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Smazat"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> doporučuje silný PIN nebo heslo – bez něj nemusí fungovat správně"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> doporučuje nové gesto, PIN nebo heslo – bez něj nemusí fungovat správně"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> vyžaduje nové gesto, PIN nebo heslo – bez něj nemusí fungovat správně"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> doporučuje nový zámek obrazovky"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Zkuste to znovu. Pokus <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> z <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Vaše data budou smazána"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Pokud při příštím pokusu zadáte nesprávné gesto, data v tomto zařízení budou smazána"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Pokud při příštím pokusu zadáte nesprávný PIN, data v tomto zařízení budou smazána"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Pokud při příštím pokusu zadáte nesprávné heslo, data v tomto zařízení budou smazána"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Pokud při příštím pokusu zadáte nesprávné gesto, tento uživatel bude smazán"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Pokud při příštím pokusu zadáte nesprávný PIN, tento uživatel bude smazán"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Pokud při příštím pokusu zadáte nesprávné heslo, tento uživatel bude smazán"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Pokud při příštím pokusu zadáte nesprávné gesto, váš pracovní profil a přidružená data budou smazány"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Pokud při příštím pokusu zadáte nesprávný PIN, váš pracovní profil a přidružená data budou smazány"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Pokud při příštím pokusu zadáte nesprávné heslo, váš pracovní profil a přidružená data budou smazány"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Heslo musí obsahovat alespoň # znak}few{Heslo musí mít alespoň # znaky}many{Heslo musí mít alespoň # znaku}other{Heslo musí mít alespoň # znaků}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Pokud jsou použity jen číslice, minimální délka je 1 číslice}few{Pokud jsou použity jen číslice, minimální délka jsou # číslice}many{Pokud jsou použity jen číslice, minimální délka je # číslice}other{Pokud jsou použity jen číslice, minimální délka je # číslic}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{PIN musí obsahovat alespoň # číslici}few{PIN musí obsahovat alespoň # číslice}many{PIN musí obsahovat alespoň # číslice}other{PIN musí obsahovat alespoň # číslic}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{PIN musí obsahovat alespoň # číslici, ale pro větší bezpečnost doporučujeme {minAutoConfirmLen}místný PIN}few{PIN musí obsahovat alespoň # číslice, ale pro větší bezpečnost doporučujeme {minAutoConfirmLen}místný PIN}many{PIN musí obsahovat alespoň # číslice, ale pro větší bezpečnost doporučujeme {minAutoConfirmLen}místný PIN}other{PIN musí obsahovat alespoň # číslic, ale pro větší bezpečnost doporučujeme {minAutoConfirmLen}místný PIN}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Heslo musí být kratší než # znak}few{Heslo musí být kratší než # znaky}many{Heslo musí být kratší než # znaku}other{Heslo musí být kratší než # znaků}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{PIN musí mít méně než # číslici}few{PIN musí mít méně než # číslice}many{PIN musí mít méně než # číslice}other{PIN musí mít méně než # číslic}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Administrátor zařízení nedovoluje použití nedávno použitého kódu PIN"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Heslo nesmí obsahovat neplatné znaky."</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Heslo musí obsahovat alespoň 1 písmeno}few{Heslo musí obsahovat alespoň # písmena}many{Heslo musí obsahovat alespoň # písmena}other{Heslo musí obsahovat alespoň # písmen}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Heslo musí obsahovat alespoň 1 malé písmeno}few{Heslo musí obsahovat alespoň # malá písmena}many{Heslo musí obsahovat alespoň # malého písmena}other{Heslo musí obsahovat alespoň # malých písmen}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Heslo musí obsahovat alespoň 1 velké písmeno}few{Heslo musí obsahovat alespoň # velká písmena}many{Heslo musí obsahovat alespoň # velkého písmena}other{Heslo musí obsahovat alespoň # velkých písmen}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Heslo musí obsahovat alespoň 1 číslici}few{Heslo musí obsahovat alespoň # číslice}many{Heslo musí obsahovat alespoň # číslice}other{Heslo musí obsahovat alespoň # číslic}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Heslo musí obsahovat alespoň 1 speciální symbol}few{Heslo musí obsahovat alespoň # speciální symboly}many{Heslo musí obsahovat alespoň # speciálního symbolu}other{Heslo musí obsahovat alespoň # speciálních symbolů}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Heslo musí obsahovat alespoň 1 znak jiný než písmeno}few{Heslo musí obsahovat alespoň # znaky jiné než písmena}many{Heslo musí obsahovat alespoň # znaku jiného než písmena}other{Heslo musí obsahovat alespoň # znaků jiných než písmena}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Musí obsahovat alespoň 1 znak jiný než číslici}few{Heslo musí obsahovat alespoň # znaky jiné než číslice}many{Heslo musí obsahovat alespoň # znaku jiného než číslice}other{Heslo musí obsahovat alespoň # znaků jiných než číslice}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Administrátor zařízení neumožňuje použít heslo, které jste použili nedávno"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Posloupnost rostoucích, klesajících nebo opakujících se číslic není povolena"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Potvrdit"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Vymazat"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Zámek obrazovky se už změnil. Zadejte nový zámek obrazovky."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Zrušit"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Další"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Aplikace pro správu zařízení"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Žádné aktivní aplikace"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aktivní aplikace}few{# aktivní aplikace}many{# aktivní aplikace}other{# aktivních aplikací}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Agenti důvěry"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Před použitím nejdříve nastavte zámek obrazovky"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Žádné"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 aktivní agent důvěry}few{# aktivní agenti důvěry}many{# aktivního agenta důvěry}other{# aktivních agentů důvěry}}"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Spárovat se zařízením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="5310869364570266209">"Přidat nového člena do existující koordinované sady"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Párovací kód Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Zadejte párovací kód a poté stiskněte Return nebo Enter."</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"Kód PIN obsahuje písmena nebo symboly"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Obvykle 0000 nebo 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Je nutné zadat 16 číslic."</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Tento kód PIN bude možná nutné zadat i v dalším zařízení."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Tento přístupový klíč bude možná nutné zadat i v druhém zařízení."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Potvrďte párování s koordinovanou sadou"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Povolit přístup ke kontaktům a historii volání"</string>
    <string name="bluetooth_pairing_phonebook_toggle_text" msgid="2474015367387690034">"Povolit také přístup ke kontaktům a historii volání"</string>
    <string name="bluetooth_pairing_phonebook_toggle_details" msgid="1367197978487212581">"Informace se budou používat k oznamování hovorů a k dalším účelům"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"K zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> se nelze připojit."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Dostupná zařízení"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Připojit"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Odpojit"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Spárovat a připojit"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Když je připojení Bluetooth zapnuto, vaše zařízení může komunikovat s ostatními zařízeními Bluetooth v okolí."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Když je zapnuté připojení Bluetooth, zařízení může komunikovat s ostatními zařízeními Bluetooth v okolí.\n\nAplikace a služby mohou za účelem vylepšení funkcí nadále vyhledávat zařízení v okolí, i když je Bluetooth vypnuté. Lze tak například vylepšit funkce a služby založené na poloze. Toto chování můžete změnit v nastavení vyhledávání Bluetooth."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Změnit"</string>
    <string name="device_details_title" msgid="1155622417516195481">"O zařízení"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Nastavení klávesnice"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Adresa Bluetooth zařízení: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Adresa Bluetooth zařízení:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Zapomenout zařízení?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Odstranit přidružení"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Odpojit aplikaci?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> již nebude propojena se zařízením <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Experimentální. Zlepšuje kvalitu zvuku."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Zapomenout zařízení"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Odpojit aplikaci"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maximum připojených audiozařízení Bluetooth"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Vyberte maximální počet připojených audiozařízení Bluetooth"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Protokol ladění sady NFC"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Zvýšit úroveň protokolování sady NFC"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Podrobné protokolování ladění dodavatelů NFC"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Zahrnovat do zpráv o chybách dodatečné protokoly dodavatelů specifické pro zařízení, které mohou obsahovat soukromé informace."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Nefiltrovaný protokol NFC NCI"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Zaznamenávat podrobné balíčky NFC, které mohou obsahovat soukromé informace."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Restartovat zařízení?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Podrobné protokolování funkce NFC je určeno pouze pro účely vývoje. Další data funkce NFC budou zahrnuta ve zprávách o chybě, které mohou obsahovat soukromé informace. Pokud toto nastavení chcete změnit, restartujte zařízení."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Restartovat"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Odesílání"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"zrcadlení"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Povolit bezdrátové zobrazení"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"V okolí nebyla nalezena žádná zařízení."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Připojování"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Připojeno"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"Používá se"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Není k dispozici"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Možnosti bezdrátového displeje"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Zapomenout"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Hotovo"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Název"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"6 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Přihlásit se"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Otevřít web"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Zbývá: <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Platnost vyprší <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"Aplikace <xliff:g id="REQUESTER">%s</xliff:g> chce zapnout Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"Aplikace <xliff:g id="REQUESTER">%s</xliff:g> chce vypnout Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Ověřovat bajtkód aplikací k ladění"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Povolit nástroji ART ověřovat bajtkód aplikací k ladění"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Zobrazovat frekvenci obnovení"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Zobrazovat aktuální obnovovací frekvenci displeje"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Před použitím NFC vyžadovat odemknutí zařízení"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Přenos obsahu aplikace prostřednictvím NFC je připraven"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Vypnuto"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Není k dispozici, protože funkce NFC je vypnutá"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Když je funkce zapnutá, můžete přenášet obsah aplikace do jiného zařízení s funkcí NFC tak, že obě zařízení podržíte blízko sebe. Přenášet můžete například webové stránky, videa na YouTube, kontakty a další.\n\nPřiložte zařízení k sobě (zpravidla zadní stranou) a klepněte na obrazovku. Aplikace určí, jaký obsah se bude přenášet."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi-Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Použít Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Nastavení Wi-Fi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Vyberte síť Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Zapínání Wi‑Fi…"</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Vypínání Wi‑Fi…"</string>
    <string name="wifi_error" msgid="4903954145386086899">"Chyba"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"V této zemi není pásmo 5 GHz k dispozici"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"Při režimu Letadlo"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Upozorňovat na veřejné sítě"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Zobrazit oznámení, když je dostupná kvalitní veřejná síť"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Zapínat Wi-Fi automaticky"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"V dosahu kvalitních uložených sítí, jako je například vaše domácí síť, se Wi-Fi znovu zapne"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Nedostupné, protože je vypnuto určování polohy. Zapněte "<annotation id="link">"určování polohy"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Nainstalovat certifikáty"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Za účelem zlepšení přesnosti polohy mohou aplikace a služby vyhledávat sítě Wi-Fi, i když je připojení Wi-Fi vypnuté. Lze tak vylepšit funkce a služby závislé na poloze. Toto chování můžete změnit v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastavení vyhledávání Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Pokud chcete zpřesnit určování polohy, zapněte vyhledávání Wi-Fi v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastavení vyhledávání Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Automaticky přepínat na mobilní data"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Když Wi-Fi nebude mít přístup k internetu, použije se mobilní datové připojení. Za využití dat mohou být účtovány poplatky."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Přidat síť"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Předvolby Wi-Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi se automaticky znovu zapne"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi‑Fi se automaticky znovu nezapne"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi‑Fi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Chcete-li zobrazit dostupné sítě, zapněte Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Vyhledávání sítí…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Nemáte oprávnění ke změně sítě Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Zapnout vyhledávání Wi-Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Chcete-li zapínat Wi-Fi automaticky, nejprve zapněte vyhledávání Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Tato funkce umožňuje aplikacím a službám vyhledávat sítě Wi-Fi kdykoli, i když je připojení Wi‑Fi vypnuté. Lze tak například zlepšit funkce a služby závislé na poloze."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Zapnout"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Vyhledávání Wi‑Fi je zapnuto"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Rozšířené možnosti"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Rozbalovací seznam Pokročilé možnosti"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"rozbalit"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Název sítě"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Zadejte SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Zabezpečení"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Skrytá síť"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Pokud router nevysílá ID sítě, ale vy se k síti budete chtít v budoucnu připojit, můžete síť nastavit jako skrytou.\n\nToto opatření může představovat bezpečnostní riziko, protože telefon bude pravidelně vysílat signál za účelem nalezení sítě.\n\nPokud tuto síť nastavíte jako skrytou, nastavení routeru tím nezměníte."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Síla signálu"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Stav"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Rychlost odkazu pro přenos"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Rychlost odkazu k přijímání"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Rychlost připojení"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frekvence"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP adresa"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Uloženo pomocí"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"<xliff:g id="NAME">%1$s</xliff:g> – identifikační údaje"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"Metoda EAP"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Ověření Phase 2"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Certifikát CA"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Minimální verze TLS"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Stav online certifikátu"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Doména"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Certifikát uživatele"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identita"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonymní identita"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Heslo"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Zobrazovat heslo"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Pásmo 2,4 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Upřednostňované pásmo 5,0 GHz"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Nastavení IP adresy"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Ochrana soukromí"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Odběr"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Zobrazení nebo změna odběru"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Náhodná adresa MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Přidání zařízení"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Chcete-li zařízení přidat do sítě <xliff:g id="SSID">%1$s</xliff:g>, níže vycentrujte QR kód"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Naskenovat QR kód"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Chcete-li se připojit k síti <xliff:g id="SSID">%1$s</xliff:g>, níže vycentrujte QR kód"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Naskenováním QR kódu se připojíte k síti Wi-Fi"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Sdílení sítě Wi-Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Pokud se chcete připojit k síti <xliff:g id="SSID">%1$s</xliff:g>, naskenujte tento QR kód jiným zařízením"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Chcete-li se připojit k síti <xliff:g id="SSID">%1$s</xliff:g>, naskenujte tento QR kód"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Zkuste to znovu. Pokud problém přetrvává, obraťte se na výrobce zařízení"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Něco se pokazilo"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Zkontrolujte, zda je zařízení zapojeno, nabito a zapnuto"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Zkontrolujte, zda je zařízení zapojeno, nabito a zapnuto. Pokud problém přetrvává, obraťte se na výrobce zařízení"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Toto zařízení neumožňuje přidání sítě <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Zkuste zařízení přesunout blíže k přístupovému bodu / routeru Wi‑Fi"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Zkontrolujte heslo a zkuste to znovu"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Kontaktujte výrobce zařízení"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Zkontrolujte připojení a zkuste to znovu"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Vybrat síť"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Chcete-li zařízení připojit, vyberte síť"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Přidat toto zařízení do sítě <xliff:g id="SSID">%1$s</xliff:g>?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi se sdílí se zařízením"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Přidat další zařízení"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Vybrat jinou síť"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Zařízení se nepodařilo přidat"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Bylo nalezeno zařízení"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Sdílení Wi‑Fi s tímto zařízením…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Připojování…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Sdílení hotspotu"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Potvrďte, že jste to vy"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Heslo k Wi-Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Heslo k hotspotu: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automatické připojení"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Povolit připojení k této síti, když bude v dosahu"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Přidat zařízení"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Pomocí QR kódu přidejte zařízení do této sítě"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR kód není platný formát"</string>
    <string name="retry" msgid="7542103800274026915">"Zkusit znovu"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Sdílet s ostatními uživateli zařízení"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(nezměněno)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Vyberte"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Bylo přidáno několik certifikátů)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Použít certifikáty systému"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Neposkytovat"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Začít důvěřovat při prvním použití"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Název sítě je příliš dlouhý."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Zadejte doménu."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Je vyžadován certifikát."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"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_turn_on_message_unknown" msgid="4903345360745717385">"Neznámá aplikace chce zapnout vyhledávání sítí (kvůli lepšímu určení polohy a dalším účelům) i v případě, že je vypnutá 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_confirm_allow" msgid="4154200627800959777">"Povolit"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Zamítnout"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Tato síť nemá přístup k internetu. Chcete zůstat připojeni?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Některé aplikace služby kvůli omezenému připojení nebudou fungovat. Přesto použít?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"U této sítě se již nedotazovat"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Síť Wi‑Fi nemá přístup k internetu"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Při špatném připojení Wi‑Fi můžete přepnout na mobilní síť. Mohou být účtovány poplatky za data."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Přepnout na mobilní data"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Zůstat na Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Již nikdy nezobrazovat"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Připojit"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Připojení Wi-Fi je zapnuto"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Připojeno k <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Připojování k síti <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Připojování…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Připojení k síti se nezdařilo."</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Síť není v dosahu"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Zapomenout"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Upravit"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Uložit"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Uložení sítě se nezdařilo."</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Zrušit"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Zapomenout síť?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 síť}few{# sítě}many{# sítě}other{# sítí}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 předplatné}few{# předplatná}many{# předplatného}other{# předplatných}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 síť a předplatné}few{# sítě a předplatná}many{# sítě a předplatného}other{# sítí a předplatných}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Adresa MAC zařízení"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Náhodná adresa MAC"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Náhodná adresa MAC (naposledy použitá)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Podrobnosti sítě"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Maska podsítě"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Typ"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"Adresy IPv6"</string>
    <string name="hotspot_device_details_category" msgid="3110651914598697220">"Podrobnosti o zařízení s hotspotem"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Zdroj internetu"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"Wi-Fi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Mobilní data"</string>
    <string name="internet_source_ethernet" msgid="8338472576454100966">"Ethernet"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Připojení přes hotspot"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Síla připojení"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Uložené sítě"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Odběry"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Ostatní sítě"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Zadejte platnou IP adresu."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Zadejte prosím platnou adresu brány."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Zadejte prosím platnou adresu DNS."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Zadejte prosím délku síťové předpony v rozsahu 0 až 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (pokud není přepsán soukromým DNS)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (pokud není přepsán soukromým DNS)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Brána"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Délka síťové předpony"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi‑Fi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Vyhledat zařízení"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Hledání…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Přejmenovat zařízení"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Partnerská zařízení"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Uložené skupiny"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Nelze připojit."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Zařízení se nepodařilo přejmenovat."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Odpojit?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"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="4490648217799144078">"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="8476985132989357041">"Zrušit pozvánku?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"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="4880242270742385699">"Zapomenout tuto skupinu?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Wi‑Fi hotspot"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"S jinými zařízeními se nesdílí ani internet, ani obsah"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Není nastaveno žádné heslo"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Název hotspotu"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Heslo hotspotu"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Pásmo přístupového bodu"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Hotspot automaticky vypínat"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Když nejsou připojena žádná zařízení"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Rozšířit kompatibilitu"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Pomůže ostatním zařízením najít tento hotspot. Snižuje rychlost připojení hotspotu."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Pomůže ostatním zařízením najít tento hotspot. Zvyšuje využití baterie."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Rychlost a kompatibilita"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2,4 GHz / Kompatibilní s většinou zařízení"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz / Kompatibilní s mnoha zařízeními"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz / Kompatibilní s méně zařízeními"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2,4 a 5 GHz / Kompatibilní s většinou zařízení"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Zvolte frekvenci pro hotspot. Tato frekvence má vliv na rychlost připojení a typy zařízení, které hotspot dokážou najít."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Preferovaná frekvence"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Pomalejší rychlosti. Kompatibilní s většinou zařízení."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Vysoké rychlosti. Kompatibilní s mnoha zařízeními."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 a 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Vysoké rychlosti. Tento dvoupásmový hotspot je kompatibilní s většinou zařízení."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Nejrychlejší rychlosti. Kompatibilní s méně zařízeními."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Ve vaší zemi nebo oblasti není k dispozici"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Pokud vámi preferovaná frekvence nebude k dispozici, hotspot může použít jinou. Pokud frekvenci změníte, může se změnit nastavení zabezpečení hotspotu."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"S frekvencí 6 GHz není k dispozici"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Pokud frekvenci hotspotu změníte, může se změnit nastavení zabezpečení"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Okamžitý hotspot"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"Zapnuto"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Vypnuto"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Zapínání hotspotu…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Vypínání hotspotu…"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Tethering není k dispozici"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Na podrobnosti se zeptejte mobilního operátora"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"Síť <xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktivní"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Uložit tuto síť?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Ukládání…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Uloženo"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Uložení se nezdařilo. Zkuste to znovu."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Uložit sítě?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Ukládání <xliff:g id="NUMBER">%d</xliff:g> sítí…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Sítě byly uloženy"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Volání přes Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Rozšiřte volání pomocí Wi-Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Chcete-li rozšířit pokrytí, zapněte volání přes Wi-Fi"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Předvolby volání"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Předvolby volání"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Předvolba pro roaming"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Předvolba pro roaming"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Mobilní"</item>
    <item msgid="3027927219952052398">"Pouze Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Mobilní"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Pokud Wi-Fi není k dispozici, použít mobilní síť"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Pokud mobilní síť nebude k dispozici, použít Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Volání přes Wi‑Fi. Pokud bude signál Wi-Fi ztracen, hovor skončí."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"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.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="8102786488994263815">"Nouzová adresa"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Použije se jako vaše poloha, pokud uskutečníte tísňové volání přes Wi-Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Další informace"</annotation>" o funkcích soukromého režimu DNS"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Zapnuto"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktivujte volání přes Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Zapněte volání přes Wi-Fi"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Odpojeno od sítě <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Zvuk a vibrace"</string>
    <string name="account_settings" msgid="255404935489127404">"Účty"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Účty s pracovním profilem – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Účty s osobním profilem"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Profilové účty klonu"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Pracovní účet – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Osobní účet – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Hledat"</string>
    <string name="display_settings" msgid="7197750639709493852">"Displej"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Automatické otáčení obrazovky"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Vypnuto"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Zapnuto"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Zap – podle obličeje"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Rozpoznání obličeje"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Další informace o automatickém otáčení"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Rozlišení obrazovky"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Vysoké rozlišení"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Plné rozlišení"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Plné rozlišení využívá baterii intenzivněji. Po přepnutí rozlišení se některé aplikace mohou restartovat."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Vybráno"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Barvy"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Přirozené"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Zesílené"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Syté"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Adaptivní"</string>
    <string name="brightness" msgid="6216871641021779698">"Úroveň jasu"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Adaptivní jas"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Jas obrazovky se automaticky přizpůsobí okolí a činnostem. Ručním posunutím posuvníku informujete funkci adaptivního jasu o svých preferencích."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Zapnuto"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Vypnuto"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Vyvážení bílé na obrazovce"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Při složení pokračovat v používání aplikací"</string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Plynulé zobrazení"</string>
    <string name="peak_refresh_rate_summary" msgid="3627278682437562787">"U některého obsahu automaticky zvýší obnovovací frekvenci z 60 na <xliff:g id="ID_1">%1$s</xliff:g> Hz. Zvyšuje využití baterie."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Vynutit nejvyšší obnovovací frekvenci"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Vyšší obnovovací frekvence za účelem vylepšení responzivity klepnutí a kvality animace. Zvyšuje využití baterie."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Vnímavá obrazovka"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Je třeba udělit přístup k fotoaparátu"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Funkce vnímavé obrazovky potřebuje přístup k fotoaparátu. Klepnutím můžete spravovat oprávnění služeb personalizace zařízení"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Spravovat oprávnění"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Když se díváte na obrazovku, nevypne se"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Funkce vnímavá obrazovka dokáže pomocí přední kamery určit, zda se někdo na obrazovku dívá. Data se zpracovávají v zařízení a snímky se nikdy neukládají ani neodesílají do Googlu."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Zapnutí vnímavé obrazovky"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Nechat obrazovku zapnutou, když na ni koukáte"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Fotoaparát je uzamčený"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Při rozpoznávání obličeje musí být fotoaparát odemknutý"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Při použití vnímavé obrazovky musí být fotoaparát odemknutý"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Rozpoznání obličeje vyžaduje přístup k fotoaparátu. Klepnutím můžete spravovat oprávnění služeb personalizace zařízení"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Spravovat oprávnění"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Noční režim"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Noční režim obrazovku zbarví do oranžova. Čtení a sledování obrazovky při tlumeném osvětlení tak bude snazší a bude se vám lépe usínat."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Plán"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Žádný"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Zapne se ve zvoleném čase"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Zapne se od soumraku do úsvitu"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Čas zahájení"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Čas ukončení"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intenzita"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Nikdy se automaticky nezapne"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Zapne se automaticky v <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Zapne se automaticky za soumraku"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Nikdy se automaticky nevypne"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Vypne se automaticky v <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Vypne se automaticky za úsvitu"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Noční režim teď není zapnutý"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Poloha zařízení je potřeba k určení úsvitu a soumraku."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Nastavení polohy"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Zapnout"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Vypnout"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Zapnout do úsvitu"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Vypnout do soumraku"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Tmavý režim"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Plán"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Nezapne se"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Zapne se od soumraku do úsvitu"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Zapne se ve zvoleném čase"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Zapne se během nočního klidu"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Stav"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Nikdy se automaticky nezapne"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Zapne se automaticky za soumraku"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Zapne se automaticky v <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Automaticky se zapne během nočního klidu"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Nikdy se automaticky nevypne"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Vypne se automaticky za úsvitu"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Vypne se automaticky v <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Po skončení režimu nočního klidu se automaticky vypne"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tmavý motiv u některých obrazovek používá černé pozadí a prodlužuje tak výdrž baterie. Plány tmavého motivu čekají na zapnutí, dokud se obrazovka nevypne."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Tmavý motiv se aktuálně řídí plánem režimu nočního klidu"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Nastavení režimu nočního klidu"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Interval vypnutí obrazovky"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"<xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> nečinnosti"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Nenastaveno"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Tapeta"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Tapeta a styl"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Plocha, obrazovka uzamčení"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Změňte si tapetu"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Přizpůsobte si obrazovku"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Vybrat tapetu"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Přizpůsobení telefonu"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Vyzkoušejte různé styly, tapety apod."</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Spořič obrazovky"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"spořič obrazovky"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Nedostupné, protože je zapnutý režim nočního klidu"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Používat spořič obrazovky"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Při nabíjení nebo v doku"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"V doku při nabíjení"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Při nabíjení"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Při vložení do doku"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nikdy"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Zapnuto / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Vypnuto"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Kdy se má spouštět"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Probudit zvednutím zařízení"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Ambientní displej"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kdy zobrazovat"</string>
    <string name="doze_title" msgid="1523090408230862316">"Probudit obrazovku při oznámeních"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Když je obrazovka tmavá, při novém oznámení se zapne"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Vždy zobrazovat čas a informace"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Zvýšené využití baterie"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Tučný text"</string>
    <string name="title_font_size" msgid="570613010306330622">"Velikost písma"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Zvětšit nebo zmenšit text"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Nastavení zámku SIM karty"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Zámek SIM karty"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Zamknout SIM kartu"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Změnit PIN SIM karty"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"Kód PIN SIM karty"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Zamknout SIM kartu"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Odemknout SIM kartu"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Starý PIN SIM karty"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Nový PIN SIM karty"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Potvrďte nový kód PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"Kód PIN SIM karty"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Zadejte kód PIN o délce 4–8 číslic"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Kódy PIN nejsou shodné"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"PIN SIM karty byl úspěšně změněn."</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"PIN nelze deaktivovat."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"PIN nelze aktivovat."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Zrušit"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Používat pro mobilní data <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Pro mobilní data používáte <xliff:g id="CARRIER2_0">%2$s</xliff:g>. Pokud přepnete na operátora <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> už se používat nebude."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Použít <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Aktualizovat preferovanou SIM kartu?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> je jediná SIM karta v zařízení. Chcete pomocí této SIM karty volat, posílat SMS a používat mobilní data?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Zlepšit pokrytí mobilních dat?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Povolte zařízení, aby se pro mobilní data automaticky přepínalo na operátora <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g>, když bude mít lepší signál."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Hovory, zprávy a síťový provoz mohou být viditelné pro vaši organizaci."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Zadali jste nesprávný kód PIN SIM karty. Nyní musíte za účelem odemknutí zařízení kontaktovat svého operátora."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Zadali jste nesprávný PIN SIM karty. Zbývá vám # pokus, poté zařízení bude muset odemknout operátor.}few{Zadali jste nesprávný PIN SIM karty. Máte ještě # pokusy.}many{Zadali jste nesprávný PIN SIM karty. Máte ještě # pokusu.}other{Zadali jste nesprávný PIN SIM karty. Máte ještě # pokusů.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Zadali jste nesprávný PIN SIM karty. Zbývá vám jeden pokus, poté zařízení bude muset odemknout operátor."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Operace pomocí kódu PIN SIM karty se nezdařila!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Aktualizace systému"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Verze systému Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Aktualizace zabezpečení Androidu"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Verze hardwaru"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Rok výroby"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID zařízení"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Verze základního pásma"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Verze jádra"</string>
    <string name="build_number" msgid="9009733242117579826">"Číslo sestavení"</string>
    <string name="module_version" msgid="1787518340082046658">"Aktualizace systému Google Play"</string>
    <string name="battery_info" msgid="7873528123969546728">"Informace o baterii"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Nedostupné"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Úložiště"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Úložiště a mezipaměť"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Nastavení úložiště"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (slot pro SIM kartu <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (slot na SIM kartu <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (slot na SIM kartu <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (primární)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"K zobrazení je potřeba vybrat uloženou síť."</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"Verze PRL"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (slot na SIM kartu <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (slot na SIM kartu <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (primární)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Zapnuto"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Vypnuto"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Typ mobilní datové sítě"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Typ mobilní hlasové sítě"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Informace operátora"</string>
    <string name="status_data_state" msgid="525196229491743487">"Stav mobilní sítě"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Stav služby"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Síla signálu"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Síť"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Adresa MAC sítě Wi-Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Adresa MAC sítě Wi-Fi zařízení"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Adresa Bluetooth"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Sériové číslo"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Doba provozu"</string>
    <string name="battery_manufacture_date" msgid="7139426520156833987">"Datum výroby"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Datum prvního použití"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Počet cyklů"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Nedostupné"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Výpočet…"</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Přejmenovat"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Připojit"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Odpojit"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formátovat SD kartu jako přenosné úložiště"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formátovat kartu"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formátovat jako přenosné"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formátovat"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Migrovat data"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Zapomenout"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Nastavit"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Uvolnit místo"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Správa úložiště"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Uvolnit místo"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Místo můžete spravovat a uvolnit v aplikaci Files"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Další uživatelé"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_mount_success" msgid="393972242641313135">"Úložiště <xliff:g id="NAME">%1$s</xliff:g> je připojeno"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Připojení úložiště <xliff:g id="NAME">%1$s</xliff:g> se nezdařilo"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"Úložiště <xliff:g id="NAME">%1$s</xliff:g> bylo bezpečně odpojeno"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Úložiště <xliff:g id="NAME">%1$s</xliff:g> nebylo možné bezpečně odpojit"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Přejmenovat úložiště"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"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_internal_format_details" msgid="2399034372813686846">"Tuto SD kartu můžete naformátovat k ukládání fotek, videí, hudby a dalšího obsahu, abyste je mohli otevírat i v jiných zařízeních. \n\n"<b>"Všechna data na této SD kartě budou vymazána."</b>" \n\n"<b>"Před formátováním"</b>" \n\n"<b>"Zálohujte fotky a další média"</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álohujte aplikace"</b>" \nVšechny aplikace uložené v tomto úložišti <xliff:g id="NAME">^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="487689543322907311"><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="5606507270046186691">"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="379238668153099015">"Zapomenout úložiště <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"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_dialog_system" msgid="7461009051858709479">"Systém obsahuje soubory používané ke spuštění systému Android verze <xliff:g id="VERSION">%s</xliff:g>."</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Uživatelé v režimu hosta SD karty formátovat nemohou"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formátování úložiště <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Během formátování médium <xliff:g id="NAME">^1</xliff:g> neodpojujte."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"Úložiště <xliff:g id="NAME">^1</xliff:g> bylo naformátováno"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Přesuňte aplikaci <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"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_unlock" msgid="14651384927767749">"Chcete-li přesunout data, je třeba odemknout uživatele <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Probíhá přesun aplikace <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Ú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_init_v2_title" msgid="2538630338392381113">"Jak chcete toto médium <xliff:g id="NAME">^1</xliff:g> používat?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"nebo"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formátovat SD kartu jako přenosné úložiště"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Ukládejte fotky, videa, hudbu a další obsah a otvírejte je v jiných zařízeních. &lt;a href=https://support.google.com/android/answer/12153449&gt;Další informace o nastavení SD karty&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formátovat"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Nastavit později"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"<xliff:g id="NAME">^1</xliff:g> – naformátovat toto médium?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Chcete-li na médium <xliff:g id="NAME_0">^1</xliff:g> ukládat aplikace, soubory a další obsah, je třeba ho naformátovat. \n\nZformátováním média <xliff:g id="NAME_1">^2</xliff:g> dojde k vymazání jeho obsahu. Zálohujte si obsah do jiného média (<xliff:g id="NAME_2">^3</xliff:g> či jiné zařízení), pokud o obsah nechcete přijít."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Médium <xliff:g id="NAME_0">^1</xliff:g> je třeba nafornátovatm, chcete-li do něj ukládat fotky, videa, hudbu a další obsah. \n\nZformátováním média <xliff:g id="NAME_1">^2</xliff:g> dojde k vymazání jeho obsahu. Zálohujte si obsah do jiného média (<xliff:g id="NAME_2">^3</xliff:g> či jiné zařízení), pokud o obsah nechcete přijít."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formátovat médium <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Přesunout obsah na médium <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Během přesunu:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Médium <xliff:g id="NAME">^1</xliff:g> neodpojujte"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Některé aplikace nebudou fungovat"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Přesunout obsah"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Přesunout obsah později"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Přesun obsahu…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Pomalé médium <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Toto médium <xliff:g id="NAME_0">^1</xliff:g> můžete nadále používat, ale může být pomalé. \n\nAplikace uložené na médiu <xliff:g id="NAME_1">^2</xliff:g> nemusí fungovat správně a přenosy obsahu mohou trvat dlouho. \n\nZkuste použít rychlejší médium <xliff:g id="NAME_2">^3</xliff:g> nebo toto médium <xliff:g id="NAME_3">^4</xliff:g> použijte jako přenosné úložiště."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Začít znovu"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Pokračovat"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Můžete začít používat úložiště <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Můžete začít používat úložiště <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Můžete začít používat úložiště <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Stav baterie"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Stav baterie"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Komunální"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Komunální nastavení"</string>
    <string name="apn_settings" msgid="4295467389400441299">"Přístupové body"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Upravit přístupový bod"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Nenastaveno"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Nenastaveno"</string>
    <string name="apn_name" msgid="6677695784108157953">"Název"</string>
    <string name="apn_apn" msgid="5812828833797458602">"Název přístupového bodu"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proxy server"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Port"</string>
    <string name="apn_user" msgid="5831763936428279228">"Uživatelské jméno"</string>
    <string name="apn_password" msgid="7435086635953953029">"Heslo"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Proxy server systému MMS"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Port systému MMS"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Typ ověření"</string>
    <string name="apn_type" msgid="1835573305077788773">"Typ přístupového bodu"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protokol APN"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protokol APN pro roaming"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Povolit/zakázat APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"Přístupový bod je povolen"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"Přístupový bod je zakázán"</string>
    <string name="bearer" msgid="3231443241639159358">"Nositel"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Typ MVNO"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Hodnota MVNO"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Smazat přístupový bod"</string>
    <string name="menu_new" msgid="6571230342655509006">"Nový přístupový bod"</string>
    <string name="menu_save" msgid="6611465355127483100">"Uložit"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Zrušit"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Pole Jméno nesmí být prázdné."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"Název přístupového bodu nesmí být prázdný."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"Pole MCC musí obsahovat 3 číslice."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Pole MNC musí obsahovat 2 nebo 3 číslice."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operátor přidání přístupových bodů typu %s neumožňuje."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Obnovování výchozích nastavení přístupového bodu"</string>
    <string name="menu_restore" msgid="4310539620115151551">"Obnovit výchozí"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Výchozí nastavení přístupového bodu bylo obnoveno."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Možnosti resetu"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Resetovat nastavení mobilní sítě"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Touto akcí resetujete veškerá nastavení mobilní sítě"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Resetovat nastavení mobilní sítě?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Resetovat Bluetooth a Wi-Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Tímto se resetuje veškeré nastavení sítí Wi-Fi a rozhraní Bluetooth. Tuto akci nebude možné vrátit."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Resetovat"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth a Wi-Fi byly resetovány"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Vymazat eSIM karty"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Tímto krokem nezrušíte mobilní tarif. Pokud chcete stáhnout náhradní SIM karty, obraťte se na svého operátora."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Resetovat nastavení"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Chcete resetovat všechna nastavení sítí? Tuto akci nelze vrátit zpět."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Resetovat všechna nastavení sítě a vymazat eSIM karty? Tuto akci nebude možné vrátit."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Obnovit nastavení"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Obnovit nastavení?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Pro tohoto uživatele resetování sítě není k dispozici"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Nastavení sítí bylo resetováno"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"SIM karty nelze vymazat"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"eSIM kartu nelze vymazat z důvodu chyby.\n\nRestartujte zařízení a zkuste to znovu."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Vymazat data (tovární reset)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Vymazat data (tovární reset)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"hudbu"</li>\n<li>"fotky"</li>\n<li>"další uživatelská data"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Tímto krokem nebude zrušen mobilní tarif."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Všechny osobní údaje a stažené aplikace budou smazány. Tuto akci nelze vrátit zpět."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Budou smazány všechny vaše osobní údaje, včetně stažených aplikací a SIM karet. Tuto akci nelze vrátit zpět."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Vymazat všechna data?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Pro tohoto uživatele není resetování do továrního nastavení dostupné"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Mazání"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Čekejte prosím…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Nastavení hovorů"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"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="5926474044238409099">"Tethering přes USB"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Přenosný hotspot"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Tethering přes Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Sdílené připojení"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Hotspot a tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Hotspot je zapnutý, datové připojení se sdílí"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Hotspot je zapnutý"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Datové připojení se sdílí"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Když je zapnutý Spořič obrazovky, nelze sdílet datové připojení ani používat přenosné hotspoty"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Pouze hotspot"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Pouze USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Pouze Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Pouze Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Hotspot, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Hotspot, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Hotspot, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Hotspot, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Hotspot, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Hotspot, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Hotspot, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internet není sdílen s dalšími zařízeními"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Vypnuto"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Tethering"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Nepoužívat Wi‑Fi hotspot"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Sdílet internet pouze přes USB"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Sdílet internet pouze přes Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Internet sdílet pouze přes Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Sdílet internet pouze přes USB a Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Internet sdílet pouze přes USB a Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Internet sdílet pouze přes Bluetooth a Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Internet sdílet pouze přes USB, Bluetooth a Ethernet"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Tethering přes USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Tethering přes Bluetooth"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Tethering přes ethernet"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Hotspot a tethering umožňují poskytovat internet jiným zařízením prostřednictvím vašeho mobilního datového připojení. Hotspot ke sdílení obsahu s okolními zařízeními mohou vytvářet i aplikace."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Hotspot a tethering umožňují poskytovat internet jiným zařízením prostřednictvím vašeho připojení Wi-Fi nebo vašeho mobilního datového připojení. Hotspot ke sdílení obsahu s okolními zařízeními mohou vytvářet i aplikace."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Nápověda"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobilní síť"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Mobilní tarif"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Aplikace pro SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Chcete změnit aplikaci SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"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="6215622785087181275">"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="7005220310238618141">"Změnit asistenta pro Wi-Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"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="680685773455072321">"Chcete spravovat síťová připojení pomocí aplikace <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Operátor SIM karty není znám"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"Operátor <xliff:g id="OPERATOR">%1$s</xliff:g> nemá žádný známý web pro správu účtů"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Vložte SIM kartu a restartujte zařízení."</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Připojte se prosím k internetu."</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedávné žádosti o určení polohy"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Umístění pracovního profilu"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Oprávnění aplikací pro přístup k poloze"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Určování polohy je vypnuto"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{Přístup k poloze má # z {total} aplikací}few{Přístup k poloze mají # z {total} aplikací}many{Přístup k poloze má # z {total} aplikací}other{Přístup k poloze má # z {total} aplikací}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Nedávný přístup"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Zobrazit vše"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Zobrazit podrobnosti"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"V poslední době o polohu nepožádaly žádné aplikace."</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Polohu v poslední době nepoužily žádné aplikace"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Vysoké využívání baterie"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Nízké využívání baterie"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Vyhledávání Wi‑Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Povolte aplikacím a službám vyhledávat sítě Wi‑Fi, i když je připojení k sítím Wi‑Fi vypnuté. Tuto funkci lze využít například ke zlepšení funkcí a služeb založených na poloze."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Vyhledávání Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Povolte aplikacím a službám vyhledávat zařízení v okolí, i když je rozhraní Bluetooth vypnuté. Tuto funkci lze využít například ke zlepšení funkcí a služeb založených na poloze."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Služby určování polohy"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Služby určování polohy"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Používat polohu"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Časové pásmo nelze nastavit automaticky"</string>
    <string name="location_time_zone_detection_status_summary_degraded_by_settings" msgid="6198939835335841106"></string>
    <string name="location_time_zone_detection_status_summary_blocked_by_settings" msgid="5276280770344278768">"Poloha nebo služby určování polohy jsou vypnuté"</string>
    <string name="location_time_zone_detection_status_summary_blocked_by_environment" msgid="2279833212923765802"></string>
    <string name="location_time_zone_detection_status_summary_temporarily_unavailable" msgid="6586801403644278967"></string>
    <string name="location_time_zone_detection_location_is_off_dialog_title" msgid="231698690198001146">"Je požadována poloha zařízení"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Pokud chcete nastavit časové pásmo podle své polohy, zapněte určování polohy a poté aktualizujte nastavení časového pásma"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Nastavení polohy"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Opravit problém"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Zrušit"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Automatické časové pásmo je vypnuté"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Zjišťování časového pásma je deaktivováno"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Zjišťování časového pásma není podporováno"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Změny zjišťování časového pásma nejsou povoleny"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Časové pásmo se může nastavit podle polohy"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Zobrazí právní informace, stav a verzi softwaru"</string>
    <string name="legal_information" msgid="7509900979811934843">"Právní informace"</string>
    <string name="manual" msgid="3651593989906084868">"Příručka"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Regulační štítky"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Příručka k bezpečnosti a předpisům"</string>
    <string name="copyright_title" msgid="83245306827757857">"Autorská práva"</string>
    <string name="license_title" msgid="8745742085916617540">"Licence"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licence aktualizace systému Google Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Smluvní podmínky"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Systémová licence WebView"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Autorství tapet"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Poskytovatelé satelitních snímků:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Příručka"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Při načítání příručky došlo k chybě."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licence třetích stran"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Při načítání licencí došlo k chybě."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Načítání..."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Načítání..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Nastavte heslo"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Nastavte pracovní heslo"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Nastavte kód PIN"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Nastavte pracovní PIN"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Nastavte gesto"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Pro ještě lepší zabezpečení si k odemykání zařízení nastavte gesto"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Nastavte pracovní gesto"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Otisk vyžaduje nastavení hesla"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Otisk vyžaduje nastavení gesta"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Z bezpečnostních důvodů nastavte PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Otisk vyžaduje nastavení PINu"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Znovu zadejte heslo"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Znovu zadejte svoje pracovní heslo"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Zadejte pracovní heslo"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Potvrďte své gesto"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Zadejte pracovní gesto"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Znovu zadejte PIN"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Znovu zadejte svůj pracovní PIN"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Zadejte pracovní PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Hesla nejsou shodná"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Kódy PIN nejsou shodné"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Zadejte gesto ještě jednou"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Výběr odemknutí"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Heslo bylo nastaveno"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"Kód PIN byl nastaven"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Gesto bylo nastaveno"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Nastavte heslo pro odemknutí obličejem"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Nastavte gesto pro odemknutí obličejem"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Nastavte PIN pro odemknutí obličejem"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Chcete-li používat obličej nebo otisk prstu, nastavte heslo"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Chcete-li používat obličej nebo otisk prstu, nastavte gesto"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Před použitím obličeje nebo otisku nastavte PIN"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Zapomněli jste heslo?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Zapomněli jste gesto?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Zapomněli jste PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Pokud chcete pokračovat, zadejte gesto"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Pokud chcete pokračovat, zadejte PIN"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Pokud chcete pokračovat, zadejte heslo"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Pokud chcete pokračovat, zadejte pracovní gesto"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Chcete-li pokračovat, zadejte pracovní PIN."</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Chcete-li pokračovat, zadejte pracovní heslo."</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Za účelem zvýšení zabezpečení použijte gesto zařízení"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Za účelem zvýšení zabezpečení zadejte PIN zařízení"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Za účelem zvýšení zabezpečení zadejte heslo zařízení"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Za účelem zvýšení zabezpečení použijte pracovní gesto"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Za účelem zvýšení zabezpečení zadejte pracovní PIN"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Za účelem zvýšení zabezpečení zadejte pracovní heslo"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Ověřte gesto"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Ověřte PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Ověřte heslo"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Ověřte svoji totožnost"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Pokud chcete přenést účty Google, nastavení a další možnosti, zadejte gesto druhého zařízení. Gesto je šifrováno."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Pokud chcete přenést účty Google, nastavení a další možnosti, zadejte PIN druhého zařízení. PIN je šifrován."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Pokud chcete přenést účty Google, nastavení a další možnosti, zadejte heslo druhého zařízení. Heslo je šifrováno."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"K odemykání zařízení používat i gesto"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"K odemykání zařízení používat i PIN"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"K odemykání zařízení používat i heslo"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Ověřte gesto"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Ověřte PIN"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Ověřte heslo"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Pokud chcete pokračovat, zadejte gesto zařízení"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Pokud chcete pokračovat, zadejte PIN zařízení"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Pokud chcete pokračovat, zadejte heslo zařízení"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Nesprávný kód PIN"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Nesprávné heslo"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Nesprávné gesto"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Stav nouze"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Zabezpečení zařízení"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Změna bezpečnostního gesta"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Změna bezpečnostního kódu PIN"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Proveďte odemykací gesto"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Nápovědu zobrazíte stisknutím klávesy Menu."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Nakonec zvedněte prst z obrazovky"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Spojte alespoň <xliff:g id="NUMBER">%d</xliff:g> tečky. Zkuste to znovu."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Gesto bylo zaznamenáno"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Potvrďte své gesto"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Nové bezpečnostní gesto"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Potvrdit"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Nakreslit znovu"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Vymazat"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Pokračovat"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Gesto odemknutí"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Požadovat gesto"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Obrazovku je třeba odemknout gestem ruky."</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Zobrazovat gesto"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Vylepšená ochrana soukromí při zadávání kódu PIN"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Deaktivovat animace při zadávání kódu PIN"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Zobrazit gesto profilu"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibrovat při klepnutí"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Okamžitě zamknout vypínačem"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"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="2193588309557281466">"Nastavení bezpečnostního gesta"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Změna bezpečnostního gesta"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Gesto odemknutí obrazovky proveďte tímto způsobem"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"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="5464331414465894254">"Aplikace není v telefonu nainstalována."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Zabezpečení pracovního profilu"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Zámek obrazovky pracovního profilu"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Používat jeden zámek"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Pro pracovní profil a obrazovku zařízení používat jeden zámek"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Používat jeden zámek?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Zařízení bude používat zámek obrazovky z pracovního profilu. Pro oba zámky budou platit stejné zásady."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Zámek pracovního profilu nesplňuje požadavky vaší organizace na zabezpečení. Pro obrazovku zařízení i pracovní profil můžete používat stejný zámek, budou se na něj však vztahovat všechny zásady platné pro pracovní zámek."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Používat jeden zámek"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Používat jeden zámek"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Stejný jako zámek obrazovky zařízení"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Spravovat aplikace"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Informace o aplikacích"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Nastavení aplikace"</string>
    <string name="install_applications" msgid="3921609656584369901">"Neznámé zdroje"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Povolit všechny zdroje aplikací"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Nedávno otevřené aplikace"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Zobrazit všechny aplikace}few{Zobrazit všechny # aplikace}many{Zobrazit všech # aplikace}other{Zobrazit všech # aplikací}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Kontaktujte administrátora IT"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Mohou vám pomoci resetovat PIN, gesto či heslo"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Upřesnit nastavení"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Povolit další možnosti nastavení"</string>
    <string name="application_info_label" msgid="1015706497694165866">"O aplikaci"</string>
    <string name="storage_label" msgid="2522307545547515733">"Úložiště"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Otevírání ve výchozím nastavení"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Výchozí aplikace"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Kompatibilita s obrazovkou"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Oprávnění"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Mezipaměť"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Vymazat mezipaměť"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Mezipaměť"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 položka}few{# položky}many{# položky}other{# položek}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Zrušit přístup"</string>
    <string name="controls_label" msgid="8671492254263626383">"Ovládací prvky"</string>
    <string name="force_stop" msgid="2681771622136916280">"Vynutit ukončení"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Celkem"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Velikost aplikace"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Aplikace úložiště USB"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Uživatelská data"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Odinstalovat"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Odinstalovat pro všechny uživatele"</string>
    <string name="install_text" msgid="4558333621516996473">"Instalovat"</string>
    <string name="disable_text" msgid="5146002260857428005">"Deaktivovat"</string>
    <string name="enable_text" msgid="8570798764647110430">"Aktivovat"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Vymazat úložiště"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Odinstalovat aktualizace"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Povolit omezená nastavení"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Některé aktivity, které jste vybrali, se otevírají v této aplikaci podle výchozího nastavení."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Této aplikaci jste povolili vytváření widgetů a přístup k jejich datům."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Aplikace není nastavena jako výchozí pro žádné akce."</string>
    <string name="clear_activities" msgid="488089228657585700">"Vymazat výchozí předvolby"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"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="8388397595148476565">"Dotázat se při spuštění"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Upravit velikost aplikace"</string>
    <string name="unknown" msgid="8192160131923461175">"Neznámé"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Seřadit podle názvu"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Seřadit podle velikosti"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Nejnovější"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Nejčastější"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Zobrazit spuštěné služby"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Zobrazit mezipaměť"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplikace k příjmu výstražných zpráv"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Obnovit nastavení aplikací"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Obnovit nastavení aplikací?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Tímto resetujete všechny následující předvolby:\n\n"<li>"deaktivované aplikace,"</li>\n<li>"zakázaná 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<li>"nastavení využití baterie."</li>\n\n"Nepřijdete o žádná data aplikací."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Obnovit aplikace"</string>
    <string name="filter" msgid="9039576690686251462">"Filtrovat"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Vyberte možnosti filtru"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Všechny aplikace"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Deaktivované aplikace"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Stažené"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Spuštěné"</string>
    <string name="not_installed" msgid="5074606858798519449">"Pro tohoto uživ. nenainstal."</string>
    <string name="installed" msgid="2837449358488825884">"Nainstalováno"</string>
    <string name="no_applications" msgid="985069304755391640">"Žádné aplikace"</string>
    <string name="internal_storage" msgid="999496851424448809">"Interní úložiště"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Přepočítávání velikosti..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Smazat data aplikace?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Data této aplikace (včetně souborů a nastavení) budou ze zařízení trvale smazána"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Zrušit"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Smazat"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Aplikaci se nepodařilo najít na seznamu nainstalovaných aplikací."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Data aplikace v úložišti se nepodařilo vymazat."</string>
    <string name="computing_size" msgid="4915310659841174866">"Probíhá výpočet…"</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Nepodařilo se určit velikost balíčku."</string>
    <string name="version_text" msgid="7628938665256107608">"verze <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Přesunout"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Probíhá jiná migrace."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Nedostatek místa v úložišti."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Aplikace neexistuje."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Umístění instalace není platné."</string>
    <string name="system_package" msgid="7559476279008519360">"Aktualizace systému nelze nainstalovat na externí média."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Aplikaci pro správu zařízení nelze nainstalovat na externí média"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Chcete vynutit zastavení?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Vynucené zastavení může způsobit nepředvídatelné chování aplikace."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Deaktivovat aplikaci"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Pokud tuto aplikaci deaktivujete, systém Android a ostatní aplikace nemusejí fungovat správně. Připomínáme, že tuto aplikaci nelze smazat, protože byla v zařízení předem nainstalována. Deaktivováním ji vypnete a skryjete."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Obchod"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Podrobnosti o aplikaci"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Aplikace nainstalovaná z obchodu <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Další informace: <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Spuštěno"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nebylo použito)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Využití úložiště"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Probíhá restartování"</string>
    <string name="cached" msgid="5379485147573438201">"Proces na pozadí v mezipaměti"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Nic není spuštěno."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Spuštěno aplikací."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"Volno: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"Využito: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Uživatel: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Odebraný uživatel"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Paměť zařízení"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Využití paměti RAM aplikacemi"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Systém"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplikace"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Volná"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Využito"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"V mezipaměti"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Spuštěná aplikace"</string>
    <string name="no_services" msgid="3898812785511572899">"Neaktivní"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Služby"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Procesy"</string>
    <string name="service_stop" msgid="5712522600201308795">"Zastavit"</string>
    <string name="service_manage" msgid="3896322986828332075">"Nastavení"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"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="3086419998820881290">"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="4792038933517438037">"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="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: Momentálně používáno. Ovládací prvky zobrazíte klepnutím na Nastavení."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Hlavní proces, který se používá."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Služba <xliff:g id="COMP_NAME">%1$s</xliff:g> se používá."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Poskytovatel <xliff:g id="COMP_NAME">%1$s</xliff:g> se používá."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Zastavit systémovou službu?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Jazyky, vstup a gesta"</string>
    <string name="language_settings" msgid="8700174277543875046">"Jazyky a zadávání"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Jazyky"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Klávesnice"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Ke změně jazyka zařízení nemáte oprávnění."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Jazyky a zadávání"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Nástroje"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Klávesnice a metody zadávání"</string>
    <string name="system_language" msgid="1146762166579643257">"Systémové jazyky"</string>
    <string name="phone_language" msgid="5986939176239963826">"Jazyky"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automatické nahrazování"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Opravovat pravopisné chyby"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Velká písmena automaticky"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"První písmeno ve větě je automaticky velké"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automatická interpunkce"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Nastavení fyzické klávesnice"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Znak „.“ lze vložit dvojím stisknutím klávesy Mezerník."</string>
    <string name="show_password" msgid="7101900779571040117">"Zobrazovat hesla"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Při psaní se budou krátce zobrazovat zadané znaky"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"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="6449414356743946577">"Nastavení"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Jazyk"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Klávesnice"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Softwarová klávesnice"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Dostupná softwarová klávesnice"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Spravovat softwarové klávesnice"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Možnosti"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fyzická klávesnice"</string>
    <string name="show_ime" msgid="4334255501724746849">"Použít softwarovou klávesnici"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Ponechat na obrazovce, když je aktivní fyzická klávesnice"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Klávesové zkratky"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Zobrazit seznam zkratek"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Klávesnice a nástroje v pracovním profilu"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Pracovní softwarová klávesnice"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Výchozí"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Touchpad"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Touchpad a myš"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Rychlost kurzoru, gesta"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Kliknutí klepnutím"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Gesta touchpadu"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Přizpůsobte si jednotlivá navigační gesta touchpadu"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Opačné posouvání"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Při posouvání dolů se obsah posune nahoru"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Klepnutí vpravo dole"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Klepnutím na pravý dolní roh touchpadu zobrazíte další možnosti"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Rychlost kurzoru"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Naučte se gesta touchpadu"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Přejít na domovskou stránku"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Přejeďte třemi prsty nahoru kdekoli na touchpadu"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Zpět"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Přejeďte třemi prsty zleva nebo zprava"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Zobrazit nedávné aplikace"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Přejeďte třemi prsty nahoru, podržte je a pak uvolněte"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Zobrazit oznámení a Rychlé nastavení"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Přejeďte třemi prsty dolů po ploše"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Přepnout aplikace"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Přejeďte čtyřmi prsty doleva nebo doprava"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Přeskočit"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Další"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Restartovat"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Hotovo"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Zpět"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Přejeďte třemi prsty doleva nebo doprava"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Přejít na domovskou stránku"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Přejeďte třemi prsty nahoru"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Poslední aplikace"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Přejeďte třemi prsty nahoru a podržte je"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Oznámení"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Přejeďte třemi prsty dolů"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Přepnutí aplikací"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Přejeďte čtyřmi prsty doleva nebo doprava"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Modifikační klávesy"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Změnit chování kláves"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Resetovat vše"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Výchozí"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Opravdu chcete všechny modifikační klávesy resetovat do výchozího nastavení?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Hotovo"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Zrušit"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Resetovat"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Vyberte modifikační klávesu"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Vyberte novou klávesu pro <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Výchozí"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Řeč"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Rychlost kurzoru"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Herní ovladače"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Vibrace při přesměrování"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Odeslat vibrace do herního ovladače, je-li připojen"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Zvolte rozložení klávesnice"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Nastavit rozvržení klávesnice"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Přepněte klávesami ctrl+mezerník"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Výchozí"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Rozložení klávesnice"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Rozložení fyzické klávesnice"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Vlastní slovník"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Osobní slovník pro práci"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Přidávejte si do slovníku slova, která využijí aplikace, jako je Kontrola pravopisu"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Přidat"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Přidat do slovníku"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Fráze"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Další možnosti"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Méně možností"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Slovo:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Zkratka:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Jazyk:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Napište slovo"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Volitelná zkratka"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Upravit slovo"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Upravit"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Smazat"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"V uživatelském slovníku nejsou žádná slova. Pokud chcete nějaké slovo přidat, klepněte na tlačítko Přidat (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Pro všechny jazyky"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Další jazyky..."</string>
    <string name="testing" msgid="6294172343766732037">"Testování"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Softwarová klávesnice, nástroje"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Softwarová klávesnice, fyzická klávesnice, nástroje"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fyzická klávesnice"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Rozložení"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Zvolte gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Zvolte widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Vytvořit widget a povolit přístup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Po vytvoření widgetu bude moci aplikace získat přístup ke všem datům, které widget zobrazuje.\n\nAplikace: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nWidget: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"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="testing_usage_stats" msgid="4660643799010906365">"Statistika použití"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Seřadit podle času použití"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Seřadit podle posl. použití"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Seřadit podle názvu aplikace"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Naposledy použito"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Doba použití"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Přístupnost"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Nastavení přístupnosti"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Zobrazení, interakce, zvuk"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Nastavení pro slabozraké"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Toto zařízení můžete přizpůsobit svým potřebám. Funkce přístupnosti lze později změnit v Nastavení."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Změňte velikost písma"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Čtečka obrazovky"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Titulky"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Zvuk"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Obecné"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Zobrazení"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Barvy a pohyb"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ztmavit obrazovku"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaktivní ovládací prvky"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Ovládací prvky časování"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Ovládací prvky systému"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Stažené aplikace"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Experimentální"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Příznaky experimentálních funkcí"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filtrování protokolu Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Nastavené filtry"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Změny se projeví po deaktivaci a opětovné aktivaci Bluetooth"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"Filtrování protokolu PBAP Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"Filtrování protokolu MAP Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Nastavte režim filtrování. (Změny se projeví po deaktivaci a opětovné aktivaci Bluetooth)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Pokud tuto možnost chcete změnit, nastavte režim protokolu Bluetooth HCI na Povolit filtrované"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Čtečka obrazovky určená primárně pro nevidomé a slabozraké"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Klepněte na položky na obrazovce, které si chcete nechat nahlas přečíst"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Předvolby titulků"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Předvolby titulků"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Další informace o předvolbách titulků"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Zvětšení"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Zkratka pro zvětšení"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Zvětšit psaní"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Lupa sleduje text během psaní"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Při přepínání mezi aplikacemi ponechat zapnuté"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Lupa zůstane zapnutá a při přepnutí mezi aplikacemi se oddálí"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Joystick"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Lupu aktivujete a posouváte pomocí joysticku na obrazovce. Klepněte na obrazovku a podržte ji, poté přetahováním prstu po joysticku ovládejte lupu. Joystick můžete přesunout klepnutím a přetažením."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Zvětšení"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Další informace o zvětšení"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Typ zvětšení"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Můžete zvětšit celou obrazovku, její část nebo přepínat mezi oběma možnostmi"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Celá obrazovka"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Část obrazovky"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Přepínání mezi celou obrazovkou a částí obrazovky"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Výběr způsobu zvětšení"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Zvětšit celou obrazovku"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Zvětšit část obrazovky"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Přepínat mezi celou obrazovkou a částí obrazovky"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Požadovanou možnost vyberete klepnutím na přepínač"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Přepnout na tlačítko přístupnosti?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Zvětšování části obrazovky trojitým klepnutím může vést k různým zpožděním, například při psaní.\n\nTlačítko přístupnosti pluje na obrazovce nad ostatními aplikacemi. Když na něj klepnete, část obrazovky se zvětší."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Přepnout na tlačítko přístupnosti"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Použít trojité klepnutí"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Klávesnice se může zpomalit"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Při zvětšování části obrazovky trojitým klepnutím může dojít k problémům s klávesnicí.\n\nLze tomu předejít změnou zkratky pro zvětšení z trojitého klepnutí na jinou možnost.\n"<annotation id="link">"Změnit nastavení"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Přesto pokračovat"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Zrušit"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Nastavení zvětšení"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Zvětšení zkratkou"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Zvětšení zkratkou a trojitým klepnutím"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Zobrazovaná velikost a text"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Změňte způsob zobrazení textu"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Předmět: Návrhy horkovzdušného balónu"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Od: Bill"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Dobré ráno!\n\nChci se jen zeptat, jak jsou na tom návrhy. Budou hotové, než začneme vyrábět nové balóny?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Resetovat nastavení"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Velikost zobrazení a nastavení textu byly resetovány"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Resetovat velikost obrazovky a text?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Resetovat"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Máš plány na víkend?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Jdu na pláž. Přidáš se?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Možnosti"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Přiblížení obrazovky"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Trojitým klepnutím aktivujete přiblížení"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Přiblížení zobrazení klepnutím na tlačítko"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Obrazovku si můžete rychle přiblížit, aby byl obsah větší."</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Přiblížení:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Zvětšení spusťte pomocí zkratky.&lt;br/&gt; {1,number,integer}. Klepněte na obrazovku.&lt;br/&gt; {2,number,integer}. Po obrazovce se pohybujte přetažením dvou prstů.&lt;br/&gt; {3,number,integer}. Přiblížení upravte stažením a roztažením dvou prstů.&lt;br/&gt; {4,number,integer}. Zvětšení ukončete pomocí zkratky.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Dočasné přiblížení:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Zkontrolujte, zda je typ zvětšení nastaven na celou obrazovku.&lt;br/&gt; {1,number,integer}. Zvětšení spusťte pomocí zkratky.&lt;br/&gt; {2,number,integer}. Podržte jakékoli místo na obrazovce.&lt;br/&gt; {3,number,integer}. Po obrazovce se pohybujte přetažením prstu.&lt;br/&gt; {4,number,integer}. Zvětšení ukončete zvednutím prstu."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Když je zapnuté zvětšení, můžete přibližovat obsah na obrazovce.\n\n"<b>"Chcete-li obsah přiblížit"</b>", spusťte zvětšení a poté klepněte kamkoliv na obrazovku.\n"<ul><li>"Přetažením dvěma nebo více prsty můžete obsah posouvat."</li>\n<li>"Stažením nebo roztažením dvou či více prstů upravíte přiblížení."</li></ul>\n\n<b>"Chcete-li obsah přiblížit dočasně"</b>", spusťte zvětšení a poté se dotkněte libovolného místa na obrazovce a podržte ho.\n"<ul><li>"Přetažením se můžete pohybovat po obrazovce."</li>\n<li>"Zvednutím prstu zobrazení vrátíte do původního stavu."</li></ul>\n\n"Na klávesnici a navigačním panelu přiblížení není k dispozici."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Strana <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> z <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Otevření pomocí tlačítka přístupnosti"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Otevřete podržením tlačítek hlasitosti"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Otevřete trojitým klepnutím na obrazovku"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Otevření gestem"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Použití gesta přístupnosti"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Tuto funkci použijete klepnutím na tlačítko Přístupnost <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> v dolní části obrazovky.\n\nChcete-li přepnout mezi funkcemi, tlačítko Přístupnost podržte."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Pokud chcete použít tuto funkci, klepněte na tlačítko přístupnosti."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Tuto funkci použijete tak, že stisknete a podržíte obě tlačítka hlasitosti."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Zvětšení aktivujete nebo deaktivujete trojitým klepnutím kamkoliv na obrazovce."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Tuto funkci použijete tak, že přejedete dvěma prsty z dolního okraje obrazovky nahoru.\n\nPokud chcete přepnout mezi funkcemi, přejeďte dvěma prsty nahoru a podržte je."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Tuto funkci použijete tak, že přejedete třemi prsty z dolního okraje obrazovky nahoru.\n\nChcete-li přepnout mezi funkcemi, přejeďte třemi prsty nahoru a podržte je."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Funkce pro usnadnění přístupu použijete tak, že přejedete dvěma prsty z dolního okraje obrazovky nahoru.\n\nPokud chcete přepnout mezi funkcemi, přejeďte dvěma prsty nahoru a podržte je."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Funkce pro usnadnění přístupu použijete tak, že přejedete třemi prsty z dolního okraje obrazovky nahoru.\n\nChcete-li přepnout mezi funkcemi, přejeďte třemi prsty nahoru a podržte je."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"OK"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="6797349445794031781">"Nastavení tlačítka"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"<xliff:g id="SERVICE">%1$s</xliff:g> – zkratka"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Tlačítko přístupnosti"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Gesto přístupnosti"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Přejetí nahoru dvěma prsty"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Přejetí nahoru třemi prsty"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Klepnutí na tlačítko přístupnosti"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Použití gesta přístupnosti"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Klepněte na tlačítko přístupnosti <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> ve spodní části obrazovky.\n\nChcete-li přepnout mezi funkcemi, podržte tlačítko přístupnosti."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Přejeďte dvěma prsty ze spodní části obrazovky nahoru.\n\nPokud chcete přepnout mezi funkcemi, přejeďte nahoru dvěma prsty a podržte je."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Přejeďte třemi prsty ze spodní části obrazovky nahoru.\n\nChcete-li přepnout mezi funkcemi, přejeďte nahoru třemi prsty a podržte je."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Další možnosti"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Další informace o funkci <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Podržení tlačítek hlasitosti"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"podržení tlačítek hlasitosti"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Podržte obě tlačítka hlasitosti"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Trojité klepnutí na obrazovku"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"trojité klepnutí na obrazovku"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Rychle {0,number,integer}krát klepněte na obrazovku. Tato zkratka může zařízení zpomalit."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Rozšířená nastavení"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Tlačítko Přístupnost je nastaveno na službu <xliff:g id="SERVICE">%1$s</xliff:g>. Chcete-li použít zvětšení, klepněte na tlačítko Přístupnost, podržte jej a vyberte zvětšení."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Gesto usnadnění přístupu je nastaveno na funkci <xliff:g id="SERVICE">%1$s</xliff:g>. Chcete-li použít zvětšení, přejeďte dvěma prsty ze spodní části obrazovky nahoru a podržte obrazovku. Potom vyberte zvětšení."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Zkratka tlačítka hlasitosti"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Nastavení zkratek"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Zkratka z obrazovky uzamčení"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Můžete povolit, aby zkratka přístupnosti fungovala i na obrazovce uzamčení. Stačí, když na několik sekund podržíte obě tlačítka hlasitosti."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Tlačítko přístupnosti"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Tlačítko a gesto přístupnosti"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Rychle zapněte funkce pro usnadnění přístupu na libovolné obrazovce"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Tlačítko přístupnosti"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Tlačítko a gesto přístupnosti"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Další informace o tlačítku a gestu přístupnosti"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Použije se tlačítko přístupnosti. Toto gesto není k dispozici u navigace třemi tlačítky."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Rychlý přístup k funkcím pro usnadnění přístupu"</string>
    <string name="accessibility_button_gesture_description" msgid="1141723096904904336">"&lt;b&gt;Jak na to&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Přejděte do nastavení přístupnosti&lt;br/&gt; {1,number,integer}. Vyberte funkci a klepněte na zkratku&lt;br/&gt; {2,number,integer}. Vyberte tlačítko nebo gesto, které chcete použít pro přístup k funkci&lt;br/&gt;"</string>
    <string name="accessibility_button_description" msgid="7669538706120092399">"&lt;b&gt;Jak na to&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Přejděte do nastavení přístupnosti&lt;br/&gt; {1,number,integer}. Vyberte funkci a klepněte na zkratku&lt;br/&gt; {2,number,integer}. Vyberte tlačítko, které chcete použít pro přístup k funkci&lt;br/&gt;"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Používat tlačítko nebo gesto"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Umístění"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Velikost"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Vybledne, když se nepoužívá"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Zmizí po několika sekundách, takže je obrazovka lépe vidět"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Průhlednost, když se nepoužívá"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Průhledné"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Neprůhledné"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Text s vysokým kontrastem"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Změnit barvu textu na černou nebo bílou, čímž se maximalizuje kontrast vůči pozadí."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Automaticky aktualizovat přiblížení"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Aktual. přiblížení obrazovky při přepnutí aplikací"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Vypínač ukončí hovor"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Velký kurzor myši"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Zvýraznit ukazatel myši"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Odstranit animace"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Omezit pohyb na obrazovce"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Zvuk mono"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Při přehrávání zvuku kombinovat kanály"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Vyvážení zvuku"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Vlevo"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Vpravo"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Výchozí"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekund"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekund"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minuta"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minuty"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Čas na provedení akce (časový limit)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Čas na provedení akce (časový limit přístupnosti)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Další informace o čase na provedení akce (časovém limitu přístupnosti)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Čas na akci"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Tuto časovou předvolbu podporují jen některé aplikace"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Vyberte, jak dlouho se mají zobrazovat dočasné zprávy s výzvami k akci"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Prodleva přidržení"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Převrácení barev"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Převrátit barvy"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Zkratka pro převrácení barev"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Převrácení barev změní světlou obrazovku na tmavou. Změní také tmavou obrazovku na světlou."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Upozornění&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Barvy se změní v médiích a obrázcích.&lt;/li&gt; &lt;li&gt; Převrácení barev funguje ve všech aplikacích.&lt;/li&gt; &lt;li&gt; Pokud chcete mít tmavé pozadí, stačí použít tmavý motiv.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"přejdete do nastavení"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Automatické klikání (doba setrvání)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Automatické klikání (doba setrvání)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Další informace o automatickém klikání (doba setrvání)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Můžete nastavit, aby připojená myš automaticky klikla, když se kurzor na určitou dobu přestane pohybovat"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Automatické klikání se může hodit, když je pro vás obtížné klikat na myš."</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Automatické klikání vypnuto"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Krátká"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekundy"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Střední"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekundy"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Dlouhá"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekunda"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Vlastní"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Kratší"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Delší"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Doba automatického klikání"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibrace a hmatová odezva"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Nastavení síly vibrace pro různá použití"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Zapnuto"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Vypnuto"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Nastavení bylo vypnuto, protože je zařízení nastaveno na tichý režim"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Volání"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Oznámení a budíky"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interaktivní hmatová odezva"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Používat vibrace a hmatovou odezvu"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Vibrace u budíku"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Vibrace u médií"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibrace při vyzvánění"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibrace při oznámení"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Odezva při klepnutí"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Používat aplikaci <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Otevřít aplikaci <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"Aplikace <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> byla přidána do Rychlého nastavení. Po přejetí prstem dolů ji můžete kdykoli zapnout nebo vypnout."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Aplikaci <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> také můžete v horní části obrazovky přidat do Rychlého nastavení"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Korekce barev byla přidána do Rychlého nastavení. Po přejetí prstem dolů ji můžete kdykoli zapnout nebo vypnout."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Korekci barev také můžete v horní části obrazovky přidat do Rychlého nastavení"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Převrácení barev bylo přidáno do Rychlého nastavení. Po přejetí prstem dolů jej můžete kdykoli zapnout nebo vypnout."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Převrácení barev také můžete v horní části obrazovky přidat do Rychlého nastavení"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Funkce Velmi tmavé byla přidána do Rychlého nastavení. Po přejetí prstem dolů ji můžete kdykoli zapnout nebo vypnout."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Funkci Velmi tmavé také můžete v horní části obrazovky přidat do Rychlého nastavení"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Režim jedné ruky byl přidán do Rychlého nastavení. Po přejetí prstem dolů jej můžete kdykoli zapnout nebo vypnout."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Režim jedné ruky také můžete v horní části obrazovky přidat do Rychlého nastavení"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Velikost písma byla přidána do Rychlého nastavení. Přejetím prstem dolů velikost písma kdykoli změníte."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Zavřít"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Používat korekci barev"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Zkratka pro korekci barev"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Korekce barev"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Další informace o korekci barev"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Převrácení barev"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Další informace o převrácení barev"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Zobrazovat titulky"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Jen pro podporovanou aplikaci"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Velikost a styl titulků"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"<xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g> velikost textu"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Další možnosti"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Upravte velikost a styl titulků, abyste je mohli snadno číst"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Tyto předvolby titulků podporují jen některé mediální aplikace."</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Tlačítko přístupnosti"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Přejetí dvěma prsty zdola nahoru"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Podržení tlačítek hlasitosti"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Přiblížení trojitým klepnutím"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Pokračovat"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Naslouchátka"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"S telefonem můžete používat naslouchátka, kochleární implantáty a další zesilovací zařízení"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nejsou připojena žádná naslouchátka"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Přidat naslouchátka"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Spárování naslouchátek"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Na další obrazovce vyberte naslouchátka. Možná budete muset spárovat pravé a levé ucho samostatně.\n\nUjistěte se, zda jsou naslouchátka zapnutá a připravená k párování."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> je aktivní"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, pouze levé"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, pouze pravé"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, levé i pravé"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> +1 další"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Spárovat nové zařízení"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"Informace o párování nového zařízení"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Naslouchátka"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Uložená zařízení"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Ovládání naslouchátek"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Zkratka naslouchátka"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilita s naslouchátky"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Zlepšuje kompatibilitu s indukčními cívkami a snižuje nežádoucí šum"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Informace o naslouchátkách"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Ujistěte se, že je vaše naslouchátko zapnuté a připravené ke spárování."</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Spárování naslouchátek"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Dostupná naslouchátka"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Nevidíte své naslouchátko?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Zobrazit další zařízení"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Úprava zvuku"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Hlasový popis"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Poslouchat popis dění na obrazovce u podporovaných filmů a pořadů"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"hlasový popis, zvuk, popis, slabozrakost"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Zkratka zapnuta"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Vypnuto"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Zapnuto"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Vypnuto"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Nefunguje. Klepnutím zobrazíte informace."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Tato služba nefunguje."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Zkratky pro usnadnění přístupu"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Zobrazit v rychlém nastavení"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Červená a zelená"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Červená a zelená"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Modrá a žlutá"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Zešednutí obrazovky"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Oslabené vidění zelené barvy, deuteranomálie"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Oslabené vidění červené barvy, protanomálie"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomálie"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Velmi tmavé"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Nastavit velmi tmavou obrazovku"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Zkratka pro snížení jasu"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Velmi tmavé"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Obrazovku si můžete ztmavit. Bude se vám tak lépe číst."</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intenzita"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Snížit jas"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Zvýšit jas"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Po restartování zařízení tuto funkci ponechat zapnutou"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Krátká ({time} s)}few{Krátká ({time} s)}many{Krátká ({time} s)}other{Krátká ({time} s)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Střední ({time} s)}few{Střední ({time} s)}many{Střední ({time} s)}other{Střední ({time} s)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Dlouhá ({time} s)}few{Dlouhá ({time} s)}many{Dlouhá ({time} s)}other{Dlouhá ({time} s)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} sekunda}few{{time} sekundy}many{{time} sekundy}other{{time} sekund}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Nastavení"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Zapnuto"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Vypnuto"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Náhled"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standardní možnosti"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Jazyk"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Velikost textu"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Styl titulků"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Vlastní možnosti"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Barva pozadí"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Neprůhlednost pozadí"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Barva okna titulků"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Neprůhlednost okna titulků"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Barva textu"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Neprůhlednost textu"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Barva okraje"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Typ okraje"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Rodina písem"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Titulky budou vypadat takto"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Výchozí"</string>
    <string name="color_title" msgid="2511586788643787427">"Barva"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Výchozí"</string>
    <string name="color_none" msgid="3703632796520710651">"Žádná"</string>
    <string name="color_white" msgid="1896703263492828323">"Bílá"</string>
    <string name="color_gray" msgid="8554077329905747877">"Šedá"</string>
    <string name="color_black" msgid="9006830401670410387">"Černá"</string>
    <string name="color_red" msgid="5210756997426500693">"Červená"</string>
    <string name="color_green" msgid="4400462091250882271">"Zelená"</string>
    <string name="color_blue" msgid="4997784644979140261">"Modrá"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Tyrkysová"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Žlutá"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Purpurová"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Má mít <xliff:g id="SERVICE">%1$s</xliff:g> plnou kontrolu nad vaším zařízením?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> potřebuje:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Žádost o oprávnění je blokována jinou aplikací. Nastavení proto vaši odpověď nemůže ověřit."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"Služba <xliff:g id="SERVICE">%1$s</xliff:g> požaduje plnou kontrolu nad zařízením. Služba může číst obrazovku a vykonávat akce namísto uživatelů, kteří potřebují usnadnění přístupu. Tato úroveň kontroly není u většiny aplikací vhodná."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Plná kontrola je vhodná u aplikací, které vám pomáhají s usnadněním přístupu. U většiny aplikací však vhodná není."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Zobrazení a ovládání obrazovky"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Služba může číst veškerý obsah obrazovky a zobrazovat ho přes ostatní aplikace."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Zobrazení a provádění akcí"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Služba může sledovat vaše interakce s aplikací nebo hardwarovým senzorem a komunikovat s aplikacemi namísto vás."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Povolit"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Zakázat"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Ukončit"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Zrušit"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Vypnout funkci <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Klepnutím na <xliff:g id="STOP">%1$s</xliff:g> ukončíte službu <xliff:g id="SERVICE">%2$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Žádná služba není nainstalována"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Není vybrána žádná služba"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"K dispozici není žádný popis."</string>
    <string name="settings_button" msgid="2195468788019730377">"Nastavení"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"citlivost na světlo, fotofobie, tmavý motiv, migréna, bolest hlavy, režim čtení, noční režim, snížení jasu, bílý bod"</string>
    <string name="keywords_accessibility" msgid="8593989878379366798">"zrak, sluch, nevidomý, neslyšící, pohyb, obratnost, asistenční, asistence, snadné používání, snadný přístup, ruka, pomoc"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Zvětšení oken, velikost zobrazení, zoom, zvětšení, slabozrakost, zvětšit"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Titulky pro neslyšící, skryté titulky, Okamžitý přepis, nedoslýchavost, ztráta sluchu, převod řeči na text, titulky"</string>
    <string name="keywords_live_transcribe" msgid="3226990195174890997"></string>
    <string name="keywords_sound_notifications" msgid="8183107485754075413"></string>
    <string name="keywords_sound_amplifier" msgid="939404835256246663"></string>
    <string name="keywords_display_size" msgid="5286419615221231518">"velikost obrazovky, velká obrazovka"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Vysoký kontrast, slabozrakost, tučné písmo"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"upravit barvu"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"ztmavení obrazovky, zesvětlení obrazovky"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"barevný kontrast"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="6811744211216280998">"pohyb, myš, externí myš, náhlavní myš, adaptivní myš, invalidní vozík, joystick"</string>
    <string name="keywords_hearing_aids" msgid="4657889873249157071">"naslouchátka, nedoslýchavost, ztráta sluchu, kochleární implantáty, zesilovací zařízení, zvukové procesory, osobní zesilovač zvuku"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"nedoslýchavost, ztráta sluchu, titulky pro neslyšící, Teletype, tty"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="keywords_3_button_navigation" msgid="436361965016404218">"tři tlačítka"</string>
    <string name="keywords_touch_and_hold_delay" msgid="7854640156419599912">"obratnost, pohyb, senior, artritida, syndrom rsi, mozková mrtvice, třes, roztroušená skleróza, mozková obrna, poškození z opakovaného namáhání, ruka"</string>
    <string name="keywords_accessibility_timeout" msgid="8903766864902000346">"prodleva, obratnost, senior"</string>
    <string name="print_settings" msgid="8519810615863882491">"Tisk"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Vypnuto"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 tisková služba je zapnutá}few{# tiskové služby jsou zapnuté}many{# tiskové služby je zapnutých}other{# tiskových služeb je zapnutých}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 tisková úloha}few{# tiskové úlohy}many{# tiskové úlohy}other{# tiskových úloh}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Tiskové služby"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Žádná služba není nainstalována"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Nebyly nalezeny žádné tiskárny"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Nastavení"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Přidat tiskárny"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Zapnuto"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Vypnuto"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Přidat službu"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Přidat tiskárnu"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Vyhledávání"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Vyhledávání tiskáren"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Služba je vypnuta"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Tiskové úlohy"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Tisková úloha"</string>
    <string name="print_restart" msgid="4424096106141083945">"Restartovat"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Storno"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"Konfigurace úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Tisk úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Rušení úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Chyba tiskárny u úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Tiskárna blokuje úlohu <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Vyhledávací pole se zobrazuje"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Vyhledávací pole je skryto"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Další informace o této tiskárně"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Baterie"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Co využívá baterii"</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"Zbývá <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do nabití"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Slabá baterie"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Povolit aplikaci spouštění na pozadí"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Omezit aktivitu na pozadí?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Pokud u aplikace omezíte aktivitu na pozadí, může dojít k nepředvídatelnému chování"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Aplikace není nastavena k optimalizaci baterie, nelze ji tedy omezit.\n\nChcete-li ji omezit, nejprve zapněte optimalizaci."</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Neomezeno"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimalizováno"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Omezeno"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Na pozadí lze využívat baterii neomezeně. Může být náročnější na baterii."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimalizuje se podle využití. Doporučeno pro většinu aplikací."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Na pozadí je využití baterie omezeno. Aplikace nemusí fungovat podle očekávání. Oznámení se mohou zpožďovat."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Změna způsobu využití baterie může ovlivnit výkon aplikace."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Tato aplikace vyžaduje využití baterie typu: <xliff:g id="STATE">%1$s</xliff:g>."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"neomezeno"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimalizováno"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Další informace o možnostech využití baterie"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Využití obrazovky od úplného nabití"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Využití baterie"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Podrobnosti historie"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Využití baterie"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Využití za posledních 24 hodin"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Zobrazit využití od posledního úplného nabití"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Spotřeba baterie aplikací"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Podrobnosti využívání"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Upravit spotřebu energie"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Zahrnuté balíčky"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Aplikace běží normálně"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Baterie je slabá"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Pokud chcete prodloužit výdrž baterie, zapněte Spořič baterie"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Prodloužení životnosti baterie"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Zapnout Správce baterie"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Zapnout spořič baterie"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Baterie se možná vybije dříve než obvykle"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Spořič baterie je zapnutý"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Další informace o spořiči baterie"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Některé funkce mohou být omezeny"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Největší využití baterie"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Zobrazte aplikace s největším využitím baterie"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Nabíjení je optimalizované za účelem ochrany baterie"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Za účelem prodloužení životnosti baterie je nabíjení optimalizované"</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Nabíjení je optimalizované za účelem ochrany baterie"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"Za účelem prodloužení životnosti baterie je nabíjení v doku optimalizované"</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Nabíjení je optimalizované za účelem ochrany baterie"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"Za účelem prodloužení životnosti baterie je nabíjení v doku optimalizované"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Nabíjení do úplného nabití"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"Za účelem ochrany baterie bude příští nabíjení v doku optimalizované"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Další informace o pozastavením nabíjení"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Obnovit nabíjení"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Zahrnuje energeticky náročnou aktivitu na pozadí"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Omezit # aplikaci}few{Omezit # aplikace}many{Omezit # aplikace}other{Omezit # aplikací}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{Aplikace {label} byla nedávno omezena}few{# aplikace byly nedávno omezeny}many{# aplikace bylo nedávno omezeno}other{# aplikací bylo nedávno omezeno}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{Aplikace {label} má vysokou míru využití baterie na pozadí}few{# aplikace mají vysokou míru využití baterie na pozadí}many{# aplikace má vysokou míru využití baterie na pozadí}other{# aplikací má vysokou míru využití baterie na pozadí}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Tuto aplikaci nelze spustit na pozadí}few{Tyto aplikace nelze spustit na pozadí}many{Tyto aplikace nelze spustit na pozadí}other{Tyto aplikace nelze spustit na pozadí}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Omezit aplikaci?}few{Omezit # aplikace?}many{Omezit # aplikace?}other{Omezit # aplikací?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Pokud chcete ušetřit energii baterie, zakažte aplikaci <xliff:g id="APP">%1$s</xliff:g> využívat baterii na pozadí. Aplikace poté nemusí fungovat správně a oznámení se mohou zobrazovat se zpožděním."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Chcete-li ušetřit energii baterie, zakažte těmto aplikacím využívat baterii na pozadí. Omezené aplikace nemusí fungovat správně a jejich oznámení se mohou zobrazovat se zpožděním.\n\nAplikace:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Chcete-li ušetřit energii baterie, zakažte těmto aplikacím využívat baterii na pozadí. Omezené aplikace nemusí fungovat správně a jejich oznámení se mohou zobrazovat se zpožděním.\n\nAplikace:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Omezit"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Odstranit omezení?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Aplikace začne využívat baterii na pozadí. Baterie se možná vybije dřív, než se očekávalo."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Odstranit"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Zrušit"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Úplně nabít"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Problém s nabíjecím příslušenstvím"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Další informace o nekompatibilním nabíjení"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Správce baterie"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Automatická správa aplikací"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Když Správce baterie zjistí, že aplikace vybíjejí baterii, dostanete možnost tyto aplikace omezit. Omezené aplikace nemusí fungovat správně a jejich oznámení se mohou zobrazovat se zpožděním."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Omezené aplikace"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{# aplikace má omezeno využívání baterie}few{# aplikace mají omezeno využívání baterie}many{# aplikace má omezeno využívání baterie}other{# aplikací má omezeno využívání baterie}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Omezeno <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"U těchto aplikací je omezeno využití baterie na pozadí. Nemusejí fungovat podle očekávání a oznámení se mohou zpožďovat."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Použít správce baterie"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Zjišťovat, zda aplikace vybíjejí baterii"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Zjišťování, kdy aplikace vybíjejí baterii"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Zjišťování, kdy aplikace vybíjejí baterii"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# aplikace je omezena}few{# aplikace jsou omezeny}many{# aplikace je omezeno}other{# aplikací je omezeno}}"</string>
    <string name="battery_header_title_alternate" msgid="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="400958471814422770">"Při čtení měřiče baterie se vyskytl problém."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Klepnutím zobrazíte další informace o této chybě"</string>
    <string name="power_screen" msgid="4596900105850963806">"Displej"</string>
    <string name="power_cpu" msgid="1820472721627148746">"Procesor"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Svítilna"</string>
    <string name="power_camera" msgid="4778315081581293923">"Fotoaparát"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Mobilní síť"</string>
    <string name="power_phone" msgid="2768396619208561670">"Hlasové hovory"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Využití obrazovky: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> bylo použito aplikací <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> z celkové kapacity baterie"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Přehled od posledního úplného nabití"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Poslední úplné nabití"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Přibližná výdrž na plné nabití"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Zbývající doba výdrže baterie je přibližná a může se změnit podle způsobu používání."</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Využití baterie"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Žádné využití od posledního úplného nabití"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Za posledních 24 hodin žádné využití"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"od posledního úplného nabití"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Systémové aplikace"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Jiné"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Odhadovaný zbývající čas"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Do úplného nabití"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Odhad se může měnit podle používání"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Mediaserver"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimalizace aplikací"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Sdílení datového připojení"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Odebrané aplikace"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Spořič baterie"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Zapnout automaticky"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Žádný plán"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Na základě vašeho sledu činností"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Zapne se dle sledu činností"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Na základě procenta"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Spořič baterie se zapne, když bude pravděpodobné, že se baterie vybije dřív, než zařízení obvykle nabíjíte."</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Zapne se při <xliff:g id="PERCENT">%1$s</xliff:g>."</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Nastavení plánu"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Prodloužení výdrže baterie"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Vypnout při nabití"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Vypínat při <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Spořič baterie se vypne při nabití baterie na <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Zapnout"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Používat spořič baterie"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Zapnout automaticky"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nikdy"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"při <xliff:g id="PERCENT">%1$s</xliff:g> baterie"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Procento baterie"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Zobrazovat procento baterie na stavovém řádku"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Stav baterie od posledního úplného nabití"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Úroveň baterie za posledních 24 hodin"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Využití ze strany aplikací od posledního úplného nabití"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Využití baterie aplikacemi za posledních 24 hodin"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Využití ze strany systému od posledního úplného nabití"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Využití baterie systémem za posledních 24 hodin"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Využití baterie systémem: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Využití baterie aplikací: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Využití systémem od posledního nabití do <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Využití aplikacemi od posledního nabití do <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Celkem: méně než minuta"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Na pozadí: méně než minuta"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Doba používání: méně než minuta"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Celkem: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Na pozadí: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Doba používání: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Údaje o využití baterie budou k dispozici za pár hodin po úplném nabití."</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"teď"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g>–<xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g> <xliff:g id="HOUR">%2$s</xliff:g>⁠"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Graf využití baterie"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Graf denního využití baterie"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Graf hodinového využití baterie"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Využití baterie od posledního úplného nabití"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Využití baterie: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Doba používání od posledního úplného nabití"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Doba používání: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Zobrazit podle aplikací"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Zobrazit podle systémů"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_cycle_count_footer" msgid="3642121059800373545">"Vzhledem ke kontrolám kvality před odesláním nemusí být při prvním použití počet cyklů nula."</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Statistiky procesů"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Podrobné statistiky běžících procesů"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Využití paměti"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"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="4391502694312709148">"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="4094034441562453522">"na pozadí"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"v popředí"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"v mezipaměti"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"OS Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Nativní"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Jádro"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Mezipaměti"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Využití RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Využití RAM (pozadí)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Doba běhu"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Procesy"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Služby"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Doba trvání"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Podrobnosti o paměti"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 hodiny"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 hodin"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 hodin"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 den"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Zobrazit systémové aplikace"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Skrýt systémové aplikace"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Zobrazit procenta"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Použít USS"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Typ statistik"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Pozadí"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Na popředí"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"V mezipaměti"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Hlasový vstup a výstup"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Nastavení hlasového vstupu a výstupu"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Hlasové vyhledávání"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Klávesnice Android"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Nastavení hlasového zadávání"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Hlasové zadávání"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Služby hlasového zadávání"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Úplná aktivace klíčových slov a interakce"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Jednoduchý převod řeči na text"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"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="on_device_recognition_settings" msgid="6503160369314598069">"Nastavení rozpoznávání na zařízení"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Rozpoznávání na zařízení"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Rozpoznávání řeči na zařízení"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Preferovaný modul"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Nastavení modulu"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Rychlost řeči a výška hlasu"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Modul"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Hlasy"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Mluvený jazyk"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Instalace hlasů"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Pokračujte do aplikace <xliff:g id="TTS_APP_NAME">%s</xliff:g> a nainstalujte hlasy"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Do aplikace"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Zrušit"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Obnovit"</string>
    <string name="tts_play" msgid="2945513377250757221">"Přehrát"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"Síť VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Nezabezpečeno"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"Nezabezpečeno: <xliff:g id="VPN_COUNT">%d</xliff:g>"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"Nezabezpečeno: <xliff:g id="VPN_COUNT">%d</xliff:g>"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Adaptivní připojení"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Prodlužuje životnost baterie a zlepšuje výkon zařízení tím, že automaticky spravuje síťová připojení"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Zapnuto"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Vypnuto"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Používat adaptivní připojení"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Úložiště pověření"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Instalace certifikátu"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Vymazání pověření"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Odstranit všechny certifikáty"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Důvěryhodná pověření"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Zobrazit důvěryhodné certifikáty CA"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Identifikační údaje uživatele"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Zobrazit a změnit uložené identifikační údaje"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Rozšířené nastavení"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Pro tohoto uživatele jsou identifikační údaje nedostupné."</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Nainstalováno pro síť VPN a aplikace"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Nainstalováno pro síť Wi-Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Nainstalováno pro síť Wi-Fi (používá se)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Odstranit veškerý obsah?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Úložiště pověření je vymazáno."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Úložiště pověření nelze smazat."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Přístup k dat. o používání"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Certifikát CA"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Certifikát pro VPN a aplikaci"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Certifikát Wi‑Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Nebude zajištěno soukromí vašich dat"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Certifikáty CA slouží k šifrování na webech, v aplikacích a v sítích VPN. Instalujte pouze certifikáty CA od organizací, kterým důvěřujete. \n\nPokud nainstalujete certifikát CA, jeho vlastník může získat přístup k vašim údajům (například heslům nebo podrobnostem o platebních kartách) z webů a aplikací, které používáte – a to i když tyto informace budou šifrované."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Neinstalovat"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Přesto nainstalovat"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Certifikát nebyl nainstalován"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Povolit aplikaci "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" instalovat certifikáty do tohoto zařízení?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Níže uvedené aplikace a adresy URL vás díky těmto certifikátům budou moci ověřit, protože s nimi bude sdíleno jedinečné ID vašeho zařízení"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Nepovolovat"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Povolit"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Zobrazit více"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Aplikace na správu certifikátů"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Žádná"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Níže uvedené aplikace a adresy URL vás díky těmto certifikátům budou moci ověřit"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Odinstalovat certifikáty"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Odstranit aplikaci"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Odebrat tuto aplikaci?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Tato aplikace nebude spravovat certifikáty, ale zůstane v zařízení. Certifikáty nainstalované touto aplikací budou odinstalovány."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# adresa URL}few{# adresy URL}many{# adresy URL}other{# adres URL}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Signál nouzového vytáčení"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Nastavit chování při tísňovém volání"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Zálohování"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Zapnuto"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Vypnuto"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Zálohování a obnovení"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Osobní údaje"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Zálohování mých dat"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Zálohovat data aplikací, hesla sítí Wi-Fi a další nastavení na serverech Google"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Záložní účet"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Spravovat účet k zálohování"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Zahrnout data aplikací"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automatické obnovení"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Při přeinstalaci aplikace obnovit zálohovaná nastavení a další data"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Služba zálohování není aktivní"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Aktuálně nejsou zálohovaná data ukládána do žádného účtu."</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"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="2379053988557486162">"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="971587401251601473">"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="31392408594557070">"Nastavení administrátora zařízení"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Aplikace pro správu zařízení"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deaktivovat tuto aplikaci pro správu zařízení"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Odinstalovat aplikaci"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deaktivovat a odinstalovat"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Aplikace pro správu zařízení"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Nejsou k dispozici žádné aplikace pro správu zařízení"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Nejsou k dispozici žádní zástupci důvěryhodnosti."</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Aktivovat aplikaci pro správu zařízení?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktivovat tuto aplikaci pro správu zařízení"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Administrátor zařízení"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Aktivací této aplikace pro správu 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_warning_simplified" msgid="2715756519899116115">"Toto zařízení bude spravovat a sledovat aplikace <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Tato aplikace pro správu 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="2774489881662331549">"Aktivovat správce profilů?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Povolit dohled?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Budete-li pokračovat, bude uživatel spravován administrátorem, který kromě vašich osobních dat bude moci ukládat také přidružená 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 zařízení."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Ostatní možnosti váš administrátor zakázal"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Další informace"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Protokol oznámení"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Historie oznámení"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Poslední hodiny (%d)"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Odloženo"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Nedávno zavřené"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# oznámení}few{# oznámení}many{# oznámení}other{# oznámení}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Tón vyzvánění a vibrace"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Podrobnosti sítě"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Synchronizace zapnuta"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Synchronizace deaktivována"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Probíhá synchronizace..."</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Chyba synchronizace."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Synchronizace se nezdařila"</string>
    <string name="sync_active" msgid="5787407579281739975">"Synchronizace je aktivní"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Synchronizace"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Nastaly potíže se synchronizací. Služba bude brzy obnovena."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Přidat účet"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Pracovní profil zatím není k dispozici"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Pracovní aplikace"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Odstranit pracovní profil"</string>
    <string name="background_data" msgid="321903213000101158">"Data na pozadí"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Aplikace mohou kdykoli synchronizovat, odesílat a přijímat data."</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Deaktivovat data na pozadí?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"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_enabled" msgid="5794103781356455043">"Synchronizace je zapnuta"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Synchronizace vypnuta"</string>
    <string name="sync_error" msgid="846923369794727644">"Chyba synchronizace"</string>
    <string name="last_synced" msgid="1527008461298110443">"Poslední synchronizace <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Probíhá synchronizace..."</string>
    <string name="settings_backup" msgid="5357973563989458049">"Nastavení zálohování"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Zálohovat moje nastavení"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Synchronizovat"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Zrušit synchronizaci"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Klepnutím synchronizujete (poslední synchronizace proběhla <xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>)"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Kalendář"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontakty"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Nastavení synchronizace aplikací"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Data a synchronizace"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Změnit heslo"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Nastavení účtu"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Odstranit účet"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Přidat účet"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Chcete odebrat účet?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Administrátor tuto změnu zakázal"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Nelze ručně synchronizovat"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"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="delete" msgid="8330605554706263775">"Smazat"</string>
    <string name="select_all" msgid="7898929601615536401">"Vybrat vše"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Využití dat"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobilní data a Wi‑Fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Automaticky synchronizovat osobní data"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Automaticky synchronizovat pracovní data"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Změnit cyklus..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Den v měsíci, kdy se má obnovit počítání datových přenosů:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"V tomto období nevyužily datové připojení žádné aplikace."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Na popředí"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Na pozadí"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"omezeno"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Vypnout mobilní data?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Nastavit limit mobilních dat"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Nastavit limit dat 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Nastavit limit dat 2G–3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Datový limit Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobil"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G a 3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Mobilní"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Žádné"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobilní datové přenosy"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"Datové přenosy 2G a 3G"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"Datové přenosy 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Popředí:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Pozadí:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Nastavení aplikace"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Data na pozadí"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Povolit využití mobilních dat na pozadí"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Data na pozadí u aplikace omezíte nastavením limitu mob. dat."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Omezit přenosy na pozadí?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Pokud budou k dispozici 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žívání dat naleznete v nastavení aplikace."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Omezení dat na pozadí je k dispozici pouze v případě, že jste nastavili limit přenosu mobilních dat."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Zapnout automatickou synchronizaci dat?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Vypnout automatickou synchronizaci dat?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Toto nastavení šetří spotřebu dat a baterii. Nejnovější informace však budete muset získávat ruční synchronizací každého účtu. Nebudete dostávat ani oznámení o dostupných aktualizacích."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Datum obnovení cyklu sledování přenesených dat"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Datum v každém měsíci:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Nastavit"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Nastavte upozornění na využití dat"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Nastavte limit spotřeby dat"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Omezení spotřeby dat"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="12">"Pozor:"</font>\n<font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"limit"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Odebrané aplikace"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Odebrané aplikace a odebraní uživatelé"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Využití sítě"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Měřená"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Název"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Typ"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Adresa serveru"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"Šifrování PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"Tajný klíč L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Identifikátor protokolu IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Předem sdílený klíč IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Uživatelský certifikát IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Certifikát CA protokolu IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Certifikát serveru IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Zobrazit rozšířené možnosti"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"Domény vyhledávání DNS"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"Servery DNS (např. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Přesměrovávací trasy (např. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Uživatelské jméno"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Heslo"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Uložit údaje o účtu"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(nepoužívá se)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(neověřovat server)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(přijato ze serveru)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Tento typ sítě VPN nemůže zůstat trvale připojen"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Trvalé sítě VPN podporují pouze číselné adresy serverů"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"U trvalé sítě VPN musí být zadán server DNS"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Adresy serverů DNS trvalých sítí VPN musejí být číselné"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Zadané údaje trvalou síť VPN nepodporují"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Zrušit"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Zavřít"</string>
    <string name="vpn_save" msgid="683868204634860888">"Uložit"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Připojit"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Nahradit"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Upravit profil VPN"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Zapomenout"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Připojit k profilu <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Odpojit tuto síť VPN?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Odpojit"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Verze"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Zapomenout VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Nahradit stávající síť VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Nastavit trvalou síť VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Když toto nastavení zapnete, do úspěšného připojení k VPN budete odpojeni od internetu"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Stávající síť VPN bude nahrazena a do jejího úspěšného připojení budete odpojeni od internetu"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Již jste připojeni k trvalé síti VPN. Pokud se připojíte k jiné, stávající síť VPN bude nahrazena a trvalý režim vypnut."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Již jste připojeni k síti VPN. Pokud se připojíte k jiné, stávající síť VPN bude nahrazena."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Zapnout"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"Síť <xliff:g id="VPN_NAME">%1$s</xliff:g> se nedokáže připojit"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Tato aplikace trvalou síť VPN nepodporuje"</string>
    <string name="vpn_title" msgid="3068868814145870274">"Síť VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Přidat profil VPN"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Upravit profil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Smazat profil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Trvalá síť VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Nebyly přidány žádné sítě VPN"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Zajistit trvalé připojení k síti VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Aplikace tuto funkci nepodporuje"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Vždy zapnuto"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Nezabezpečeno"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Blokovat připojení bez VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Vyžadovat připojení VPN?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Nezabezpečeno. Proveďte aktualizaci na IKEv2 VPN"</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"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="455915403560910517">"Žádná"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Trvalá síť VPN vyžaduje IP adresu pro server i DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Připojení k síti není k dispozici. Zkuste to prosím znovu později."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Odpojeno od sítě VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Žádná"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Chybí certifikát. Zkuste upravit profil."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Systém"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Uživatel"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Zakázat"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Povolit"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Odinstalovat"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Důvěřovat"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Povolit certifikát CA systému?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Zakázat certifikát CA systému?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Natrvalo odstranit uživatelský certifikát CA?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Právě používá:"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Obsah záznamu:"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 klíč uživatele"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 certifikát uživatele"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 certifikát CA"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"certifikáty CA (%d)"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Podrobnosti o identifikačních údajích"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Odstraněné identifikační údaje: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Nejsou nainstalovány žádné identifikační údaje uživatele"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Kontrola pravopisu"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Kontrola pravopisu pro práci"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Sem zadejte aktuální heslo pro úplné zálohy."</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Sem zadejte nové heslo pro úplné zálohy."</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Sem znovu zadejte nové heslo pro úplné zálohy."</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Nastavit heslo pro zálohy"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Zrušit"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Další aktualizace systému"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Síť může být monitorována"</string>
    <string name="done_button" msgid="6269449526248267">"Hotovo"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Označit certifikát jako důvěryhodný nebo ho odstranit}few{Označit certifikáty jako důvěryhodné nebo je odstranit}many{Označit certifikáty jako důvěryhodné nebo je odstranit}other{Označit certifikáty jako důvěryhodné nebo je odstranit}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{Administrátor organizace {orgName} do vašeho zařízení nainstaloval certifikační autoritu, která mu může umožňovat sledovat vaši aktivitu v pracovní síti, včetně e‑mailů, aplikací a zabezpečených webů.\n\nDalší informace o tomto certifikátu vám sdělí váš administrátor.}few{Administrátor organizace {orgName} do vašeho zařízení nainstaloval certifikační autority, které mu mohou umožňovat sledovat vaši aktivitu v pracovní síti, včetně e‑mailů, aplikací a zabezpečených webů.\n\nDalší informace o těchto certifikátech vám sdělí váš administrátor.}many{Administrátor organizace {orgName} do vašeho zařízení nainstaloval certifikační autority, které mu mohou umožňovat sledovat vaši aktivitu v pracovní síti, včetně e‑mailů, aplikací a zabezpečených webů.\n\nDalší informace o těchto certifikátech vám sdělí váš administrátor.}other{Administrátor organizace {orgName} do vašeho zařízení nainstaloval certifikační autority, které mu mohou umožňovat sledovat vaši aktivitu v pracovní síti, včetně e‑mailů, aplikací a zabezpečených webů.\n\nDalší informace o těchto certifikátech vám sdělí váš administrátor.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{Administrátor organizace {orgName} pro váš pracovní profil nainstaloval certifikační autoritu, která mu může umožňovat sledovat vaši aktivitu v pracovní síti, včetně e‑mailů, aplikací a zabezpečených webů.\n\nDalší informace o tomto certifikátu vám sdělí váš administrátor.}few{Administrátor organizace {orgName} pro váš pracovní profil nainstaloval certifikační autority, které mu mohou umožňovat sledovat vaši aktivitu v pracovní síti, včetně e‑mailů, aplikací a zabezpečených webů.\n\nDalší informace o těchto certifikátech vám sdělí váš administrátor.}many{Administrátor organizace {orgName} pro váš pracovní profil nainstaloval certifikační autority, které mu mohou umožňovat sledovat vaši aktivitu v pracovní síti, včetně e‑mailů, aplikací a zabezpečených webů.\n\nDalší informace o těchto certifikátech vám sdělí váš administrátor.}other{Administrátor organizace {orgName} pro váš pracovní profil nainstaloval certifikační autority, které mu mohou umožňovat sledovat vaši aktivitu v pracovní síti, včetně e‑mailů, aplikací a zabezpečených webů.\n\nDalší informace o těchto certifikátech vám sdělí váš administrátor.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"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="2044927302268394991">"{count,plural, =1{Zkontrolovat certifikát}few{Zkontrolovat certifikáty}many{Zkontrolovat certifikáty}other{Zkontrolovat certifikáty}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Více uživatelů"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Uživatelé a profily"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Přidat uživatele nebo profil"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Omezený profil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Není nastaveno"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Není nastaveno – omezený profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Nenastaveno – pracovní profil"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrátor"</string>
    <string name="user_you" msgid="3070562015202859996">"Vy (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Nemůžete přidat žádné další uživatele. Chcete-li přidat nového, některého odstraňte."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Pomocí omezených profilů nelze přidávat účty."</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Smazat <xliff:g id="USER_NAME">%1$s</xliff:g> ze zařízení"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Nastavení obrazovky uzamčení"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Přidávat uživatele z obrazovky uzamčení"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"V doku přepnout na administrátora"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Chcete se smazat?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Smazat tohoto uživatele?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Odstranit tento profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Odstranit pracovní profil?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Budou smazány všechny aplikace a data."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Pokud budete pokračovat, veškeré aplikace a data v tomto profilu budou vymazána."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Budou smazány všechny aplikace a data."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Přidávání nového uživatele…"</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Smazat uživatele"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Smazat"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Veškeré aplikace a data v této relaci budou vymazána."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Odstranit"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Host (vy)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Uživatelé"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Další uživatelé"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Smazat aktivitu hosta"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Při ukončení režimu hosta smazat všechny aplikace a data hosta"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Smazat aktivitu hosta?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Aplikace a data z této relace hosta budou nyní smazány a veškerá budoucí aktivita hostů bude smazána pokaždé, když opustíte režim hosta"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"smazat, host, aktivita, odstranit, data, návštěvník, vymazat"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Povolit hostovi telefonovat"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"S hostem bude sdílena historie hovorů"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Zapnout telefonní hovory a SMS"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Nastavení uživatele jako administrátora"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Smazat uživatele"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Zapnout telefonní hovory a SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"S tímto uživatelem bude sdílena historie hovorů a SMS."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Odebrat administrátorská práva?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Pokud tomuto uživateli odeberete administrátorská práva, vy nebo jiný administrátor mu je můžete později opět udělit."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Nouzové informace"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Informace a kontakty uživatele <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Otevřít aplikaci <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Povolit aplikace a obsah"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Aplikace s omezením"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Rozbalit nastavení aplikace"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Vyberte aplikace k instalaci"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Nainstalovat dostupné aplikace"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Bezkontaktní platby"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Výchozí platební aplikace"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Pokud chcete zaplatit pomocí platební aplikace, přiložte zadní stranu zařízení k platebnímu terminálu."</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Další informace"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Nastavit pracovní aplikaci jako výchozí platební aplikaci?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Chcete-li zaplatit pomocí pracovní aplikace:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"Pracovní profil musí být zapnutý."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"bude třeba zadat PIN, gesto nebo heslo pro práci, pokud ho máte."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Jak to funguje"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Plaťte v obchodech telefonem"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Výchozí platební aplikace"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Nenastaveno"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="6127665705799658860">"Používat výchozí platební aplikaci"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Používat výchozí platební aplikaci"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Vždy"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Jen pokud není spuštěna jiná platební aplikace"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Na bezkontaktním terminálu zaplaťte pomocí aplikace:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Platba na terminálu"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Nejprve si nastavte platební aplikaci. Pak už jen stačí přidržet telefon zadní stranou u terminálu se symbolem bezkontaktních plateb."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Rozumím"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Více…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Nastavení výchozí platební aplikace"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Aktualizace výchozí platební aplikace"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Na bezkontaktním terminálu zaplaťte pomocí aplikace <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Na bezkontaktním terminálu zaplaťte pomocí aplikace <xliff:g id="APP_0">%1$s</xliff:g>.\n\nBude tím nahrazena aplikace <xliff:g id="APP_1">%2$s</xliff:g> jako výchozí platební aplikace."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Výchozí nastavení"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Aktualizovat"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Práce"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Omezení"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Odebrat omezení"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Změnit PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Nápověda a zpětná vazba"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Účet pro obsah"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID fotografie"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Extrémní ohrožení"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Přijímat upozornění na extrémní ohrožení života a majetku"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Závažná ohrožení"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Přijímat upozornění na závažná ohrožení života a majetku"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Upozornění AMBER"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Přijímat bulletiny o únosech dětí"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Opakovat"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Aktivovat Správce hovorů"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Povolí této službě spravovat způsob uskutečňování hovorů."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Správce hovorů"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Bezdrátové výstražné zprávy"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Síťoví operátoři"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Názvy přístupových bodů"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Rozšířené volání"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Volání přes síť 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Používat ke zlepšení hlasových hovorů služby LTE (doporučeno)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Používat ke zlepšení hlasových hovorů služby 4G (doporučeno)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Pro hlasové hovory používat síť 5G"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Odesílat kontakty operátorovi"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Odesílejte telefonní čísla kontaktů a získejte rozšířené funkce"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Odesílat kontakty operátorovi <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Odesílat kontakty operátorovi?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Telefonní čísla vašich kontaktů budou pravidelně odesílána operátorovi <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Na základě těchto údajů se určí, zda vaše kontakty mohou používat určité funkce, např. videohovory nebo některé funkce zpráv."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Telefonní čísla vašich kontaktů budou pravidelně odesílána vašemu operátorovi.<xliff:g id="EMPTY_LINE">

</xliff:g>Na základě těchto údajů se určí, zda vaše kontakty mohou používat určité funkce, např. videohovory nebo některé funkce zpráv."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Preferovaný typ sítě"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (doporučeno)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Zprávy MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Odesílání a příjem při vypnutých mobilních datech"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Automaticky přepínat mobilní data"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Používat tuto síť, když má lepší dostupnost"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Pracovní SIM karta"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Přístup k aplikacím a obsahu"</string>
    <string name="user_rename" msgid="8735940847878484249">"PŘEJMENOVAT"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Nastavit omezení aplikací"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Řízeno aplikací <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Tato aplikace má přístup k vašim účtům"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"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="2630656989926554685">"Sítě Wi‑Fi a mobilní sítě"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Povolit úpravu nastavení sítí Wi-Fi a mobilních sítí"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Povolit úpravy párování a nastavení zařízení Bluetooth"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Poloha"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Povolit aplikaci používat informace o vaší poloze"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Zpět"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Další"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formátovat jinak"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"SIM karty"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobilní data nejsou k dispozici"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Klepnutím vyberte datovou SIM kartu"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Vždy používat pro hovory"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Vyberte SIM kartu pro mobilní data"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Vyberte SIM kartu pro SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Přepínání datových SIM karet, tato operace může chvíli trvat…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Používat pro mobilní data <xliff:g id="NEW_SIM">%1$s</xliff:g>?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Pokud přepnete na operátora <xliff:g id="NEW_SIM">%1$s</xliff:g>, <xliff:g id="OLD_SIM">%2$s</xliff:g> už se pro mobilní data používat nebude."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Použít <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Volat pomocí"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Zadejte název SIM karty"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Slot pro SIM kartu %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Oranžová"</string>
    <string name="color_purple" msgid="6603701972079904843">"Fialová"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Stav SIM karty"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Stav SIM karty (slot na SIM kartu %1$d)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="2819551384383504031">"SIM karty se změnily."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Klepnutím přejděte do Nastavení"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Pokaždé se zeptat"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Vyžadován výběr"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Výběr SIM karty"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Nastavení"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Síť a internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobilní data, Wi‑Fi, hotspot"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi‑Fi, hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Připojená zařízení"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, párování"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, režim jízdy autem, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, režim jízdy autem"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, režim jízdy autem, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, režim jízdy autem"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Nejsou dostupné, protože funkce NFC je vypnutá"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Před použitím nejprve nainstalujte platební aplikaci"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Nedávné aplikace, výchozí aplikace"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Aplikace v pracovním profilu nemají přístup k oznámením."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Hesla a účty"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Uložená hesla, automatické vyplňování, synchronizované účty"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Výchozí aplikace"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Klonované aplikace"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Vytvořte druhou instanci aplikace, abyste mohli používat dva účty současně."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Aplikace, které lze klonovat."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"Naklonované: <xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g>, dostupné k naklonování: <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g>"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Smazat všechny klony aplikace"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Smazání všech klonů aplikace neúspěšné"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Vytváření…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Naklonováno"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Vytváření klonu <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Klon <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> byl vytvořen"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Jazyky, gesta, čas, záloha"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"Systémové jazyky, jazyky aplikací, regionální preference, řeč"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, síť, připojení, internet, bezdrátové, data"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Oznámení Wi‑Fi, oznámení wifi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"využití dat"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Používat 24hodinový formát"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Otevřít pomocí aplikace"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Aplikace"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"časové pásmo"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Hlava chatu, systém, upozornění, okno, dialog, displej, nad jinými aplikacemi"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Svítilna, světlo, baterka"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, přepnout, ovládání"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobilní síť, mobilní operátor, mobilní data, bezdrátové, data, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, hovor, volání"</string>
    <string name="keywords_display" msgid="874738809280751745">"displej, dotyková obrazovka"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"ztlumení obrazovky, dotyková obrazovka, baterie, jas"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"ztlumení obrazovky, noc, tónování, noční směna, jas, barva obrazovky, barvy"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"pozadí, personalizace, přizpůsobení displeje"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"velikost textu"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projektor, odesílání, zrcadlení obrazovky, sdílení obrazovky, zrcadlení, sdílet obrazovku, odesílání obrazovky"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"místo, disk, pevný disk, využití zařízení"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"využití energie, nabití"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"zobrazení využití baterie, využití baterie"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"spořič baterie, úspora baterie"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"adaptivní předvolby, adaptivní baterie"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"pravopis, slovník, kontrola pravopisu, automatické opravy"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"rozpoznávač, vstup, řeč, mluvit, jazyk, handsfree, rozpoznávání, nevhodné, slovo, zvuk, historie, náhlavní souprava bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"sazba, jazyk, výchozí, mluvit, mluvení, převod textu na řeč, přístupnost, čtečka obrazovky, nevidomí"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"hodiny, čas"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"resetování, obnovení, tovární nastavení"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"vymazání, smazání, obnovení, odstranění, resetování do továrního nastavení"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"tiskárna"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"pípání reproduktoru, reproduktor, hlasitost, ztlumení, ticho, zvuk, hudba, hmatové, vibrace, vibrovat"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"nerušit, vyrušit, vyrušení, pauza"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"okolí, poloha, historie, hlášení, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"účet, přidání účtu, pracovní profil, přidat účet, odstranit, smazat"</string>
    <string name="keywords_users" msgid="3497517660077620843">"omezení, omezit, omezeno"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"oprava textu, opravit, zvuk, vibrace, auto, jazyk, gesto, navrhnout, návrh, motiv, nevhodné, slovo, typ, emodži, mezinárodní"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"resetování, předvolby, výchozí"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"aplikace, stahování, systém"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"aplikace, oprávnění, zabezpečení"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"aplikace, výchozí"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorování optimalizací, zdřímnutí, pohotovostní režim aplikací"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"jasné, RGB, sRGB, barva, přirozené, standardní"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, rozlišení, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"teplota barev, D65, D73, bílá, žlutá, modrá, teplé, studené"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"odemknutí přejetím prstem, heslo, gesto, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"připnutí obrazovky"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"pracovní výzva, práce, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"pracovní profil, spravovaný profil, sjednotit, sjednocení, práce, profil"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"zapnutá obrazovka, režim spánku, nezamykat, odemknutí při složení, rozkládání, zavření, vypnutá obrazovka"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gesta"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"peněženka"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"platit, klepnout, platby"</string>
    <string name="keywords_backup" msgid="707735920706667685">"záloha, zálohování"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"obličej, odemknutí, autorizace, přihlášení"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"obličej, odemknutí, ověření, přihlášení, otisk prstu, biometrika"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, verze prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"síť, stav mobilní sítě, stav služby, síla signálu, typ mobilní sítě, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"síť, stav mobilní sítě, stav služby, síla signálu, typ mobilní sítě, roaming, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"síť, stav mobilní sítě, stav služby, síla signálu, typ mobilní sítě, roaming, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"síť, stav mobilní sítě, stav služby, síla signálu, typ mobilní sítě, roaming, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"sériové číslo, verze hardwaru"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"informace o baterii, datum výroby, počet cyklů, první použití"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"úroveň opravy zabezpečení androidu, verze základního pásma, verze jádra"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"motiv, světlý, tmavý, citlivost na světlo, fotofobie, ztmavit, tmavý režim, migréna"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tmavý motiv"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"chyba"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Ambientní displej, vzhled obrazovky uzamčení"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"oznámení na obrazovce uzamčení, oznámení"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"obličej"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"otisk prstu, přidat otisk prstu"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"obličej, otisk prstu, přidat otisk prstu"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"odemknutí pomocí hodinek, přidat odemknutí pomocí hodinek"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"ztlumení obrazovky, dotyková obrazovka, baterie, chytrý jas, dynamický jas, automatický jas"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"smart, chytré, ztlumení obrazovky, spánek, baterie, časový limit, pozornost, vnímavá, displej, obrazovka, neaktivita"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"fotoaparát, kamera, smart, chytré, automatické otáčení, otočení, překlopení, rotace, na výšku, na šířku, orientace, vertikální, horizontální"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"upgradovat, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"nerušit, plán, oznámení, blokovat, ticho, vibrace, spánek, práce, soustředění, zvuk, ztlumení, den, pracovní den, víkend, noc, událost"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"obrazovka, čas uzamknutí, vypršení, zámek obrazovky, interval vypnutí"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"paměť, mezipaměť, data, smazat, vymazat, uvolnit, místo"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"připojené, zařízení, sluchátka, náhlavní souprava, reproduktor, bezdrátové, párování, hudba, média"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"pozadí, motiv, mřížka, upravit, přizpůsobit"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"ikona, zvýraznění, barva, plocha, obrazovka uzamčení, zkratka, velikost hodin"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"výchozí, asistent"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"placení, výchozí"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"příchozí oznámení"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"tethering přes usb, tethering přes bluetooth, hotspot wi-fi"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"hmatová odezva, vibrovat, vibrace"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"hmatová odezva, vibrace, obrazovka, citlivost"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"hmatová odezva, vibrace, telefon, hovor, citlivost, vyzvánění"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"hmatová odezva, vibrace, telefon, hovor, vyzvánění, postupně"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"hmatová odezva, vibrace, citlivost, oznámení"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"hmatová odezva, vibrace, citlivost, budík"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"hmatová odezva, vibrace, citlivost, média"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"hmatová odezva, vibrace"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"spořič baterie, pevné, trvalé, úspora energie, baterie"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"sled činností, plán, spořič baterie, úspora energie, baterie, automatické, procenta"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, rozšířené volání, volání 4g"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, rozšířené volání, volání 5g"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"přidat jazyk, přidání jazyka"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"velikost textu, velké písmo, velký text, slabozrakost, zvětšení textu, zvětšovač písma, zvětšení písma"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"vždy zapnuté ambientní zobrazení, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, štítek, čtečka"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Hlasitost, vibrace, režim Nerušit"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Hlasitost médií"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Hlasitost odesílání"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Hlasitost hovorů"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Hlasitost budíků"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Hlasitost vyzvánění a oznámení"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Hlasitost vyzvánění"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Hlasitost oznámení"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Tiché vyzvánění"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Vibrační vyzvánění"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Oznámení jsou ztlumena a budou vibrovat"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> má vypnutý zvuk"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Nedostupné, protože vyzvánění je ztlumené"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Vyzvánění telefonu"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Výchozí zvuk oznámení"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Zvuk z aplikace"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Výchozí zvuk oznámení"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Výchozí zvuk budíku"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Nejdřív vibrace a postupně vyzvánění"</string>
    <!-- no translation found for spatial_audio_title (1775370104206884711) -->
    <skip />
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Tóny číselníku"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Zvuk uzamčení obrazovky"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Zvuky a vibrace při nabíjení"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Zvuky při vložení do doku"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Zvuky klepání a klikání"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Vždy zobrazovat ikonu v režimu vibrací"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Zvuk reproduktoru doku"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Veškerý zvuk"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Pouze mediální soubory"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Ticho"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Zvuk"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibrace"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Zvuky při spouštění"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Živý přepis"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Automatické přepisy médií"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Sluchátka s kabelem"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Zvuk z kompatibilních mediálních zařízení bude realističtější"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Vypnuto"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Zapnuto / <xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Zapnuto / <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> a <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Prostorový zvuk můžete zapnout také pro zařízení Bluetooth."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Nastavení připojených zařízení"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Žádný}=1{Nastaven 1 plán}few{Nastaveny # plány}many{Nastaveno # plánu}other{Nastaveno # plánů}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Nerušit"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Přijímat pouze oznámení od důležitých lidí a z důležitých aplikací"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Omezení vyrušení"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Zapněte funkci Nerušit"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Vyrušovat mohou budíky a zvuky médií"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Plány"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Smazat plány"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Smazat"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Upravit"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Plány"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Plán"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Plán"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Ztlumit telefon v určitou dobu"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Nastavit pravidla režimu Nerušit"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Plán"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Použít plán"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Povolit vyrušení, která vydávají zvuk"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokovat vizuální vyrušení"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Povolit vizuální signály"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Možnosti zobrazení skrytých oznámení"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Když je zapnutý režim Nerušit"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Oznámení bez zvukového upozornění"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Oznámení se zobrazí na obrazovce"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Nová oznámení nebudou vydávat zvuk ani vibrovat."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Oznámení bez vizuálního a zvukového upozornění"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Oznámení nebudou vidět ani slyšet"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Telefon nebude zobrazovat nová ani stávající oznámení a nebude při nich ani vibrovat či vyzvánět. Kritická oznámení týkající se aktivity a stavu zařízení se však budou zobrazovat i nadále.\n\nKdyž režim Nerušit vypnete, zmeškaná oznámení zobrazíte přejetím prstem dolů z horního okraje obrazovky."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Vlastní"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Aktivovat vlastní nastavení"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Odstranit vlastní nastavení"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Oznámení bez zvukového upozornění"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Částečně skryté"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Oznámení bez vizuálního a zvukového upozornění"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Vlastní omezení"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Když je obrazovka zapnutá"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Když je obrazovka vypnutá"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Ztlumit zvuk a vibrace"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Nezapínat obrazovku"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Neblikat"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Nezobrazovat oznámení na obrazovce"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Skrýt ikony stavového řádku v horní části obrazovky"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Skrýt puntíky s oznámením na ikonách aplikací"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Neprobouzet obrazovku kvůli oznámením"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Nezobrazovat na vysouvacím panelu"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nikdy"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Při vypnuté obrazovce"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Při zapnuté obrazovce"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Zvuk a vibrace"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Zvuk, vibrace a některá vizuální upozornění na oznámení"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Zvuk, vibrace a vizuální upozornění na oznámení"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Oznámení potřebná pro základní činnost a stav zařízení nebudou nikdy skryta."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Žádné"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"další možnosti"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Přidat"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Zapnout"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Zapnout"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Vypnout"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Režim Nerušit je zapnut do <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Režim Nerušit zůstane zapnutý, dokud ho nevypnete."</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Režim Nerušit byl automaticky zapnut plánem (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Režim Nerušit byl automaticky zapnut aplikací (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Pro pravidla <xliff:g id="RULE_NAMES">%s</xliff:g> je zapnutý režim Nerušit s vlastním nastavením."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Zobrazit vlastní nastavení"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Pouze prioritní"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"Zapnuto / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Zapnuto"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Pokaždé se zeptat"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Dokud funkci nevypnete"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 hodina}few{# hodiny}many{# hodiny}other{# hodin}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minuta}few{# minuty}many{# minuty}other{# minut}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Vypnuto}=1{Vypnuto / 1 plán se může zapnout automaticky}few{Vypnuto / # plány se můžou zapnout automaticky}many{Vypnuto / # plánu se může zapnout automaticky}other{Vypnuto / # plánů se může zapnout automaticky}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Co smí vyrušovat během režimu Nerušit"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Lidé"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Aplikace"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Budíky a další vyrušení"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Plány"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Trvání Rychlého nastavení"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Obecné"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Když je zapnut režim Nerušit, zvuky a vibrace budou ztlumeny (kromě položek, které povolíte výše)."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Vlastní nastavení"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Zkontrolovat plán"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Rozumím"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Oznámení"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Trvání"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Zprávy, události a připomenutí"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Když je zapnut režim Nerušit, zprávy, připomenutí a události budou ztlumeny (kromě položek, které povolíte výše). Nastavení zpráv můžete upravit, aby vás mohli kontaktovat kamarádi, členové rodiny nebo jiní vybraní lidé."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Hotovo"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Nastavení"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Oznámení bez zobrazení i zvuku"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Oznámení bez zvuku"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Oznámení nebudou vidět ani slyšet. Hovory od kontaktů s hvězdičkou a lidí, co volají opakovaně, jsou povoleny."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Aktuální nastavení)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Chcete změnit nastavení oznámeni režimu Nerušit?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Zvuky pracovního profilu"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Používat zvuky osobního profilu"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Používat stejné zvuky jako v osobním profilu"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Vyzvánění pracovního telefonu"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Výchozí zvuk pracovního oznámení"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Výchozí zvuk pracovního budíku"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Stejné jako v osobním profilu"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Použít zvuky osobního profilu?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Potvrdit"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Pracovní profil bude používat stejné zvuky jako osobní profil"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Oznámení"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Historie oznámení, konverzace"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Konverzace"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Správa"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Oznámení z aplikací"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Ovládat oznámení z jednotlivých aplikací"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Obecné"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Pracovní oznámení"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Pracovní profil"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Adaptivní priorita oznámení"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Oznámení s nižší prioritou automaticky nastavit na Nenápadná"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Adaptivní hodnocení oznámení"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Automaticky oznámení hodnotit podle relevance"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Zpětná vazba k adaptivnímu oznámení"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Uvádět, jaké úpravy byly u oznámení provedeny, a ukazovat možnost poskytnout systému zpětnou vazbu"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Resetovat důležitost oznámení"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Resetovat nastavení důležitosti změněná uživatelem a povolit stanovení priority pomocí asistenta oznámení"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Navrhované akce a odpovědi"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Automaticky zobrazovat navrhované akce a odpovědi"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Zobrazovat nedávná a odložená oznámení"</string>
    <string name="notification_history" msgid="8663811361243456201">"Historie oznámení"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Používat historii oznámení"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Historie oznámení je vypnutá"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Po zapnutí historie oznámení uvidíte nedávná a odložená oznámení"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Žádná nedávná oznámení"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Tady se budou zobrazovat nedávná a odložená oznámení"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"zobrazit nastavení oznámení"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"otevřít oznámení"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Povolit odložení oznámení"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Puntík s oznámením na ikoně aplikace"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Bubliny"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Bubliny"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Zobrazovat tuto konverzaci jako bublinu"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Zobrazovat plovoucí ikonu přes aplikace"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Zapnout v zařízení bubliny?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Zapnutím bublin u této aplikace zapnete bubliny také v zařízení.\n\nTato akce bude mít vliv na ostatní aplikace a konverzace, kde je zobrazování bublin povoleno."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Zapnout"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Zrušit"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Zapnuto / Konverzace se mohou zobrazovat jako plovoucí ikony"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Povolit aplikacím zobrazovat bubliny"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Některé konverzace se zobrazí jako plovoucí ikony přes ostatní aplikace"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Všechny konverzace se mohou zobrazovat jako bubliny"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Vybrané konverzace se mohou zobrazovat jako bubliny"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Nic se nemůže zobrazovat jako bubliny"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Konverzace"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Jako bubliny se mohou zobrazovat všechny konverzace kromě"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Vypnout bubliny pro tuto konverzaci"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Zapnout bubliny pro tuto konverzaci"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Přejetím vpravo zavřete, přejetím vlevo zobrazíte nabídku"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Přejetím vlevo zavřete, přejetím vpravo zobrazíte nabídku"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Skrýt tichá oznámení na stavovém řádku"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Blikání kontrolky"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Soukromí"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Přeskakovat obrazovku uzamčení"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Po odemknutí přejdete přímo na naposledy používanou obrazovku. Oznámení se na obrazovce uzamčení nebudou zobrazovat. Zobrazíte je přejetím prstem dolů."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Obrazovka uzamčení, přeskočení, obejití"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Když je pracovní profil uzamčen"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Zobrazovat pouze nová oznámení na obrazovce uzamčení"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Z obrazovky uzamčení automaticky odstraňovat dříve zobrazená oznámení"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Oznámení na obrazovce uzamčení"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Zobrazovat konverzace a výchozí i tichá oznámení"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Zobrazovat konverzace a výchozí i tichá oznámení"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Skrýt tiché konverzace a oznámení"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Nezobrazovat žádná oznámení"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Citlivá oznámení"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Při uzamknutí zobrazovat citlivý obsah"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Citlivá oznámení v pracovním profilu"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Při uzamknutí zobrazovat citlivý obsah pracovního profilu"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Zobrazovat veškerý obsah oznámení"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Citlivý obsah zobrazovat jen po odemknutí"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Oznámení vůbec nezobrazovat"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Jak chcete obrazovku uzamčení zobrazovat?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Obrazovka uzamčení"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Zobrazí se veškerý obsah pracovních oznámení"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Skrýt citlivý pracovní obsah"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Jak chcete zobrazovat profilová oznámení, když bude zařízení uzamčeno?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profilová oznámení"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Oznámení"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Oznámení z aplikací"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Kategorie oznámení"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Chování"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Konverzace"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Sekce konverzací"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Povolit aplikaci používat sekci konverzací"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Není konverzace"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Odstranit ze sekce konverzací"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Toto je konverzace"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Přidat do sekce konverzací"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Žádné prioritní konverzace"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# prioritní konverzace}few{# prioritní konverzace}many{# prioritní konverzace}other{# prioritních konverzací}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Prioritní konverzace"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Zobrazovat v horní části sekce konverzací a jako plovoucí bubliny"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Zobrazovat v horní části sekce konverzací"</string>
    <string name="other_conversations" msgid="551178916855139870">"Neprioritní konverzace"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Konverzace, ve kterých jste provedli změny"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Nedávné konverzace"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Smazat nejnovější konverzace"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Nedávné konverzace byly odstraněny"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Konverzace byla odstraněna"</string>
    <string name="clear" msgid="5092178335409471100">"Vymazat"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Tady se budou zobrazovat prioritní a upravené konverzace"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Když nějakou konverzaci označíte jako prioritní nebo v konverzacích něco upravíte, zobrazí se tady. \n\nJak změnit nastavení konverzace: \nPřejetím prstem z horní části obrazovky dolů otevřete vysouvací panel a potom konverzaci podržte."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimalizovat"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Vyskakování na obrazovce"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Tichý režim"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Výchozí"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Povolit vyrušení"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Umožněte aplikacím vydávat zvuky, vibrovat nebo zobrazovat oznámení na obrazovce"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Priorita"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Zobrazuje se v horní části sekce konverzací jako plovoucí bublina a na obrazovce uzamčení se objevuje jako profilová fotka"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> většinu funkcí konverzace nepodporuje. Konverzace nelze nastavit jako prioritní a nebudou se zobrazovat jako plovoucí bubliny."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"V rozbalovacím panelu sbalit oznámení na jeden řádek"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Žádný zvuk ani vibrace"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Žádný zvuk ani vibrace a zobrazuje se níže v sekci konverzací"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Vyzvání nebo vibruje podle nastavení zařízení"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Když je zařízení odemčené, zobrazovat oznámení jako banner v horní části obrazovky"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"<xliff:g id="APP_NAME">%1$s</xliff:g>: všechna oznámení"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Všechna oznámení aplikace <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Přibližně # oznámení za den}few{Přibližně # oznámení za den}many{Přibližně # oznámení za den}other{Přibližně # oznámení za den}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Přibližně # oznámení za týden}few{Přibližně # oznámení za týden}many{Přibližně # oznámení za týden}other{Přibližně # oznámení za týden}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nikdy"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Oznámení v zařízeních a aplikacích"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Ovládat, které aplikace a zařízení mohou číst oznámení"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Přístup k oznámením pracovního profilu je zablokován"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Vylepšená oznámení"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Dostávat návrhy akcí, odpovědí a další tipy"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Žádné"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Žádné nainstalované aplikace o přístup k oznámením nepožádaly."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Povolit přístup k oznámením"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Adaptivní oznámení pro Android byla v systému Android 12 nahrazena vylepšenými oznámeními. Tato funkce ukazuje navrhované akce a odpovědi a uspořádává oznámení. \n\nVylepšená oznámení mají přístup k obsahu oznámení, včetně osobních údajů, jako jsou jména kontaktů a zprávy. Tato funkce také může zavírat oznámení nebo na ně odpovídat, například přijímat telefonní hovory a ovládat režim Nerušit."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"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="1131986567509818121">"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ů, fotky a texty zpráv, které obdržíte. Bude také moci automaticky odkládat nebo zavírat oznámení nebo aktivovat tlačítka v oznámeních, včetně přijímání telefonických hovorů. \n\nTímto také aplikaci umožníte zapínat nebo vypínat režim Nerušit a měnit související nastavení."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Aplikace <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> bude moci:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Číst vaše oznámení"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Může číst vaše oznámení, včetně osobních údajů, jako jsou kontakty, zprávy a fotky."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Odpovídat na zprávy"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Může odpovídat na zprávy a místo tlačítek odkládat či odmítat oznámení nebo přijímat hovory."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Měnit nastavení"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Může zapínat nebo vypínat režim Nerušit a měnit související nastavení."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Pokud aplikaci <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> vypnete přístup k oznámením, můžete tím vypnout i přístup k režimu Nerušit."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Vypnout"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Zrušit"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"V reálném čase"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Probíhající komunikace používaných aplikací, navigace, telefonní hovory a další"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Konverzace"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS, textové zprávy a další komunikace"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Oznámení"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Vyzvání nebo vibruje podle nastavení"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Tichý režim"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Oznámení, která nikdy nevydávají zvuk ani nevibrují"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Povoleno"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Nepovoleno"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Zobrazit všechny aplikace"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Změnit nastavení u aplikací, které zasílají oznámení"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Aplikace zobrazené na zařízení"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Tato aplikace nepodporuje rozšířená nastavení"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Další nastavení"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Další nastavení jsou k dispozici uvnitř aplikace"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Pomocné služby VR"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Žádné nainstalované aplikace nepožádaly o spuštění jako pomocná služba VR."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Povolit službě <xliff:g id="SERVICE">%1$s</xliff:g> přístup ke službě virtuální reality?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"Aplikaci <xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> bude možné spustit, i když budete používat aplikace v režimu virtuální reality."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Když je zařízení v režimu VR"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Snížit rozmazání (doporučeno)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Snížit mihotání"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Obraz v obraze"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Žádná nainstalovaná aplikace nepodporuje režim obraz v obraze"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"obraz v obraze"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Obraz v obraze"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Povolit obraz v obraze"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Jestliže tuto možnost povolíte, aplikace vytvoří okno v režimu obraz v obraze, když je otevřená nebo poté, co ji opustíte (například abyste mohli pokračovat ve sledování videa). Toto okno „pluje“ nad ostatními aplikacemi, které používáte."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Propojení pracovních a osobních aplikací"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Propojeno"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Nepropojeno"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Žádné propojené aplikace"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"více profilů propojená aplikace aplikace pracovní a osobní"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Propojeno"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Propojit tyto aplikace"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Propojené aplikace sdílejí oprávnění a mají vzájemný přístup k datům."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Propojujte pouze aplikace, kterým důvěřujete, že nebudou sdílet osobní údaje s vaším administrátorem IT."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Aplikace můžete kdykoli odpojit v nastavení ochrany soukromí v zařízení."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Svěřit pracovní aplikaci <xliff:g id="NAME">%1$s</xliff:g> vaše osobní data?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Propojujte pouze aplikace, kterým důvěřujete, že nebudou sdílet osobní údaje s vaším administrátorem IT."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Data aplikací"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Tato aplikace má přístup k datům v osobní aplikaci <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Oprávnění"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Tato aplikace může používat oprávnění osobní aplikace <xliff:g id="NAME">%1$s</xliff:g>, jako je přístup k poloze, úložišti nebo kontaktům."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Nejsou propojeny žádné aplikace"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{Je propojena # aplikace.}few{Jsou propojeny # aplikace.}many{Je propojeno # aplikace.}other{Je propojeno # aplikací.}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Chcete-li tyto aplikace propojit, nainstalujte si v pracovním profilu aplikaci <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Chcete-li tyto aplikace propojit, nainstalujte si v osobním profilu aplikaci <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Aplikaci stáhnete klepnutím"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Přístup při nastavení Nerušit"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Povolit režim Nerušit"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"O přístup při nastavení Nerušit nepožádaly žádné nainstalované aplikace"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Oznámení z této aplikace jste nepovolili"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Tato kategorie oznámení je v zařízení na vaši žádost blokována systémem Android"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Tato skupina oznámení je v zařízení na vaši žádost blokována systémem Android"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Tato aplikace neodesílá oznámení"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategorie"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Jiné"</string>
    <string name="no_channels" msgid="4716199078612071915">"Tato aplikace neodeslala žádná oznámení"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Další nastavení v aplikaci"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{Byla smazána # kategorie}few{Byly smazány # kategorie}many{Bylo smazáno # kategorie}other{Bylo smazáno # kategorií}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokovat vše"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Tato oznámení nikdy nezobrazovat"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Zobrazovat oznámení"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Nezobrazovat oznámení na panelu ani v periferních zařízeních"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Povolit oznámení na celou obrazovku"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Povolte oznámení na celou obrazovku, když bude zařízení zamknuté"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Povolit puntík s oznámením"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Zobrazovat puntík s oznámením"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Přepsat nastavení Nerušit"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Umožnit těmto oznámením vyrušit mě, pokud je zapnutý režim Nerušit"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Obrazovka uzamčení"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Hotovo"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Blikání kontrolky"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibrace"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Zvuk"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Priorita"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Název plánu"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Zadejte název plánu"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Název plánu se už používá"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Přidat další"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Přidat plán události"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Přidat časový plán"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Vyberte typ plánu"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Smazat pravidlo <xliff:g id="RULE">%1$s</xliff:g>?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Smazat"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Tato nastavení teď nelze změnit. Aplikace (<xliff:g id="APP_NAME">%1$s</xliff:g>) automaticky zapnula režim Nerušit s vlastním chováním."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Tato nastavení teď nelze změnit. Aplikace automaticky zapnula režim Nerušit s vlastním chováním."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Tato nastavení teď nelze změnit. Byl ručně zapnut režim Nerušit s vlastním chováním."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Čas"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Událost"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Během událostí"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"V libovolném kalendáři"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"V případě odpovědi"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Ano, možná nebo žádná odpověď"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Ano nebo možná"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Ano"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Pravidlo nebylo nalezeno."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Zapnuto / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Dny"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Žádná"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Budík může přepsat čas ukončení"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Po zazvonění budíku se plán vypne"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Chování režimu Nerušit"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Použít výchozí nastavení"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Vytvořit vlastní nastavení"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Pro: <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>"</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g> – <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Konverzace"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Všechny konverzace"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Prioritní konverzace"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"prioritní konverzace"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Žádné"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Žádná}=1{1 konverzace}few{# konverzace}many{# konverzace}other{# konverzací}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Kdo smí vyrušovat"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Ačkoliv vás nebudou moct informovat aplikace na odesílání zpráv nebo volání, vybraní lidé vás prostřednictvím těchto aplikací zkontaktují."</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Volání"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Volání"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"hovory"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Hovory, které smí vyrušovat"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Pokud chcete, aby povolená volání vydávala zvuk, zkontrolujte, zda je zařízení nastaveno na vyzvánění."</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"V plánu <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> jsou blokovány příchozí hovory. Nastavení můžete upravit, aby se vám dovolali kamarádi, členové rodiny nebo jiné vybrané kontakty."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Kontakty označené hvězdičkou"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Nikdo}=1{{contact_1}}=2{{contact_1} a {contact_2}}=3{{contact_1}, {contact_2} a {contact_3}}few{{contact_1}, {contact_2} a # další}many{{contact_1}, {contact_2} a # dalšího}other{{contact_1}, {contact_2} a # dalších}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Bez jména)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Zprávy"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"zprávy"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Zprávy"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Zprávy, které smí vyrušovat"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Pokud chcete, aby povolené zprávy vydávaly zvuk, zkontrolujte, zda je zařízení nastaveno na vyzvánění."</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"V plánu <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> jsou blokovány příchozí zprávy. Nastavení můžete upravit, aby se s vámi mohli spojit kamarádi, členové rodiny nebo jiné vybrané kontakty."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Zprávu vám může poslat kdokoli"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Může se vám dovolat kdokoli"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Nikdo}=1{1 kontakt}few{# kontakty}many{# kontaktu}other{# kontaktů}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Kdokoli"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontakty"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Kontakty označené hvězdičkou"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Nikdo"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Nikdo"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Budíky"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Zvuky časovačů, budíků, bezpečnostních systémů a dalších aplikací"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"budíky"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"budíky"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Zvuky médií"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Zvuky videí, her a dalších médií"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"média"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"média"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Zvuky při dotyku"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Zvuky klávesnice a dalších tlačítek"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"zvuky při dotyku"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"zvuky při dotyku"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Připomenutí"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Zvuky úkolů a připomenutí"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"připomenutí"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"připomenutí"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Události v kalendáři"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Zvuky nadcházejících událostí v kalendáři"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"události"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"události"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Povolit přepisování aplikací"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Aplikace, které smí vyrušovat"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Vybrat další aplikace"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Nebyly vybrány žádné aplikace"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Žádné aplikace nemohou vyrušovat"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Přidat aplikace"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Všechna oznámení"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Některá oznámení"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"I když aplikacím vyrušování zakážete, vybraní lidé vás stále mohou kontaktovat."</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Žádné aplikace nemohou vyrušovat}=1{Vyrušovat může aplikace {app_1}}=2{Vyrušovat mohou aplikace {app_1} a {app_2}}=3{Vyrušovat mohou aplikace {app_1}, {app_2} a {app_3}}few{Vyrušovat mohou aplikace {app_1}, {app_2} a # další}many{Vyrušovat mohou aplikace {app_1}, {app_2} a # další}other{Vyrušovat mohou aplikace {app_1}, {app_2} a # dalších}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Aplikace"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Oznámení, která smí vyrušovat"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Povolit všechna oznámení"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Nic nemůže vyrušovat}=1{Vyrušovat může {sound_category_1}}=2{Vyrušovat mohou {sound_category_1} a {sound_category_2}}=3{Vyrušovat mohou {sound_category_1}, {sound_category_2} a {sound_category_3}}few{Vyrušovat mohou {sound_category_1}, {sound_category_2} a # další zvuky}many{Vyrušovat mohou {sound_category_1}, {sound_category_2} a # dalšího zvuku}other{Vyrušovat mohou {sound_category_1}, {sound_category_2} a # dalších zvuků}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Nic nemůže vyrušovat"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Nikdo nemůže vyrušovat"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Vyrušovat mohou někteří lidé"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Všichni lidé mohou vyrušovat"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Volající, kteří volají opakovaně"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Povolit opakovaná volání"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"kdokoli"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontakty"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"kontakty s hvězdičkou"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"opakovaná volání"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> a <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Pokud stejná osoba zavolá podruhé během <xliff:g id="MINUTES">%d</xliff:g> min"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Čas zahájení"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Čas ukončení"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"Následující den v <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Přepnout do režimu Pouze budíky na dobu neurčitou"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Na minutu (tedy do {time}) přepnout do režimu Pouze budíky}few{Na # minuty (tedy do {time}) přepnout do režimu Pouze budíky}many{Na # minuty (tedy do {time}) přepnout do režimu Pouze budíky}other{Na # minut (tedy do {time}) přepnout do režimu Pouze budíky}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Na hodinu (tedy do {time}) přepnout do režimu Pouze budíky}few{Na # hodiny (tedy do {time}) přepnout do režimu Pouze budíky}many{Na # hodiny (tedy do {time}) přepnout do režimu Pouze budíky}other{Na # hodin (tedy do {time}) přepnout do režimu Pouze budíky}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"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="722093064250082317">"Přejít do režimu Vždy vyrušit"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Varování"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Zavřít"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Odeslat zpětnou vazbu o tomto zařízení"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Zadejte PIN administrátora"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Zapnuto"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Vypnuto"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Zapnuto"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Vypnuto"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Zapnuto"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Vypnuto"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Připnutí aplikace"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Připnutí aplikace vám umožňuje nechat aktuální aplikaci zobrazenou, dokud ji neodepnete. Tuto funkci lze použít, například když chcete nechat důvěryhodného přítele hrát konkrétní hru."</string>
    <string name="screen_pinning_description" msgid="5822120806426139396">"Když je aplikace připnutá, může otevírat další aplikace a mít přístup k soukromým datům. \n\nPoužití připnutí aplikace: 	\n{0,number,integer}. Zapněte připnutí aplikace 	\n{1,number,integer}. Otevřete Přehled 	\n{2,number,integer}. Klepněte na ikonu aplikace v horní části obrazovky a potom na Připnout"</string>
    <string name="screen_pinning_guest_user_description" msgid="2307270321127139579">"Když je aplikace připnutá, může otevírat další aplikace a mít přístup k soukromým datům. \n\nChcete-li s někým bezpečně sdílet zařízení, zkuste místo toho použít režim hosta. \n\nPoužití připnutí aplikace: 	\n{0,number,integer}. Zapněte připnutí aplikace 	\n{1,number,integer}. Otevřete Přehled 	\n{2,number,integer}. Klepněte na ikonu aplikace v horní části obrazovky a potom na Připnout"</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Když je aplikace připnutá: \n\n• Může mít přístup k soukromým datům \n (například kontaktům a obsahu e-mailů) \n• Připnutá aplikace může otevírat další aplikace \n\nPřipnutí aplikace používejte pouze s lidmi, kterým důvěřujete."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Před uvolněním požádat o bezpečnostní gesto"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Před uvolněním požádat o PIN"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Před odepnutím požádat o heslo"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Při odepnutí uzamknout zařízení"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Potvrzovat smazání SIM karty"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Před vymazáním eSIM karty ověřovat svoji totožnost"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Pokročilá ochrana paměti beta"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Pokročilá ochrana paměti"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Tato funkce beta pomáhá chránit zařízení před chybami, které mohou ohrozit vaši bezpečnost."</string>
    <string name="memtag_on" msgid="824938319141503923">"Zapnuto"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Vypnuto"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Po restartu zapnuto"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Po restartu vypnuto"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Pro toto zařízení momentálně nedostupné"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Pro toto zařízení vždy zapnuto"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"K zapnutí nebo vypnutí pokročilé ochrany paměti, budete zařízení muset restartovat. Když je zapnutá, může zařízení fungovat pomaleji."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Restartovat zařízení?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"K zapnutí pokročilé ochrany paměti, budete zařízení muset restartovat."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"K vypnutí pokročilé ochrany paměti budete zařízení muset restartovat."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Restartovat"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Teď ne"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Další informace o pokročilé ochraně paměti."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Tento pracovní profil spravuje aplikace:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Spravováno aplikací <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Otevírání ve výchozím nastavení"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Otevírat podporované odkazy"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Povolit otevírání webových odkazů v této aplikaci"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Odkazy, které se mají otevřít v této aplikaci"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Podporované odkazy"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Ostatní výchozí předvolby"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Přidat odkaz"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Aplikace může ověřovat odkazy, aby se v ní mohly automaticky otevírat."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# ověřený odkaz}few{# ověřené odkazy}many{# ověřeného odkazu}other{# ověřených odkazů}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Odkaz je ověřený a automaticky se otevře v této aplikaci.}few{Odkazy jsou ověřené a automaticky se otevřou v této aplikaci.}many{Odkazy jsou ověřené a automaticky se otevřou v této aplikaci.}other{Odkazy jsou ověřené a automaticky se otevřou v této aplikaci.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Zobrazit seznam ověřených odkazů"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Hledání ostatních podporovaných odkazů…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Zrušit"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# podporovaný odkaz}few{# podporované odkazy}many{# podporovaného odkazu}other{# podporovaných odkazů}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Přidat"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Otevře se v aplikaci <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<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="979243131665635278">"Interní úložiště"</string>
    <string name="storage_type_external" msgid="125078274000280821">"externí úložiště"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"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="2591194906751432725">"Využití úložiště"</string>
    <string name="change" msgid="273206077375322595">"Změnit"</string>
    <string name="change_storage" msgid="8773820275624113401">"Změnit úložiště"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Oznámení"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Zapnuto"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g> / <xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"Vypnuto"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# kategorie byla vypnuta}few{# kategorie byly vypnuty}many{# kategorie bylo vypnuto}other{# kategorií bylo vypnuto}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# další oprávnění}few{# další oprávnění}many{# dalšího oprávnění}other{# dalších oprávnění}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Nebyla udělena žádná oprávnění"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Dosud nebyla vyžádána žádná oprávnění"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Spravujte přístup aplikací k vašim datům"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Panel ochrany soukromí"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Zobrazení aplikací, které v poslední době využívaly oprávnění"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Nepoužívané aplikace"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# nepoužívaná aplikace}few{# nepoužívané aplikace}many{# nepoužívané aplikace}other{# nepoužívaných aplikací}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Nastavení nepoužívaných aplikací"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Pozastavit aktivitu při nepoužívání"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Odebrat oprávnění, smazat dočasné soubory a zastavit oznámení"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Všechny aplikace"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Nainstalované aplikace"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Okamžité aplikace"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Vypnuto"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Rozšířená nastavení"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Správce oprávnění"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Aktualizace sdílení dat pro zjišťování polohy"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Zkontrolujte aplikace, které změnily způsob, jakým mohou sdílet vaše údaje o poloze"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Probudit klepnutím"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Dvojitým klepnutím kamkoli na obrazovku zařízení probudíte"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Otevírání odkazů"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Neotevírat podporované odkazy"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Otevírat adresy z domény <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Otevírat doménu <xliff:g id="DOMAIN">%s</xliff:g> a další adresy URL"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Povolit aplikaci otevírat podporované odkazy"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Pokaždé se zeptat"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Nepovolovat aplikaci otevírat odkazy"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Aplikace tvrdí, že spravuje # odkaz}few{Aplikace tvrdí, že spravuje # odkazy}many{Aplikace tvrdí, že spravuje # odkazu}other{Aplikace tvrdí, že spravuje # odkazů}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Aplikace tvrdí, že spravuje následující odkazy:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Asistence a hlasové zadávání"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Aplikace digitálního asistenta"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Výchozí digitální asistent"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Souhlasím"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Prohlížeč"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Aplikace na telefonování"</string>
    <string name="system_app" msgid="1863291702508355041">"(Systém)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Úložiště aplikací"</string>
    <string name="usage_access" msgid="5487993885373893282">"Přístup k údajům o využití"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Povolit přístup k údajům o využití"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Čas strávený na zařízení"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Přístup k údajům o využití umožňuje aplikaci sledovat, které ostatní aplikace používáte, jak často je používáte, jakého máte operátora, nastavení jazyka a další podrobnosti."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Paměť"</string>
    <string name="always_running" msgid="9012705720688200252">"Vždy spuštěno (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Spuštěno občas (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Spuštěno výjimečně (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g> / <xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Optimalizace baterie"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Neoptimalizováno"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Neoptimalizováno"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimalizace využívání baterie"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Optimalizace výdrže baterie není k dispozici"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Povolit aplikaci stále běžet na pozadí?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Pokud aplikaci <xliff:g id="APP_NAME">%1$s</xliff:g> povolíte, aby stále běžela na pozadí, může to zkrátit životnost baterie. \n\nSvoji volbu můžete později změnit v nabídce Nastavení &gt; Aplikace."</string>
    <string name="battery_summary" msgid="2491764359695671207">"Od posledního úplného nabití bylo využito <xliff:g id="PERCENTAGE">%1$s</xliff:g> baterie"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"Za posledních 24 hodin použito <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Od posledního úplného nabití nebyla baterie využita"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Sdílet zprávu o chybě?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Administrátor IT si vyžádal zprávu o chybě, aby mohl problém odstranit. Aplikace a data mohou být sdílena."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Administrátor IT si vyžádal zprávu o chybě, aby mohl problém odstranit. Mohou být sdíleny aplikace a data a zařízení se může dočasně zpomalit."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Tato zpráva o chybě je sdílena s administrátorem IT. Ten vám také poskytne další informace."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Sdílet"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Odmítnout"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Žádný přenos dat"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Nabíjet připojené zařízení"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Přenos souborů"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Webkamera"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Převádět videa do formátu AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videa bude možné přehrát ve více přehrávačích médií, ale může se zhoršit kvalita"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Tethering přes USB"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Používat USB pro:"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Výchozí konfigurace USB"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Tato nastavení se použijí, když bude telefon odemknut a připojí se jiné zařízení. Připojujte pouze důvěryhodná zařízení."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Možnosti napájení"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Možnosti přenosu souborů"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Předvolby USB"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"Zařízení ovládající USB:"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Připojené zařízení"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Toto zařízení"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Přepínání…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Nelze přepnout"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Nabíjení tohoto zařízení"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Nabíjení připojeného zařízení"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Přenos souborů"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Tethering přes USB"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Webkamera"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Přenos souborů a energie k nabíjení"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Tethering přes USB a energie k nabíjení"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP a energie k nabíjení"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI a energie k nabíjení"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Webkamera a napájení"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Kontrola pozadí"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Použití textu z obrazovky"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Asistenční aplikace bude mít přístup k obsahu obrazovky v textové podobě"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Použití snímku obrazovky"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Asistenční aplikace bude mít přístup ke snímku obrazovky"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Zablikání obrazovky"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Když asistenční aplikace z obrazovky nebo snímku obrazovky získá text, okraje obrazovky zablikají"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Asistenční aplikace pomáhají na základě informací na zobrazené obrazovce. Některé aplikace podporují spouštěče i hlasový vstup, a nabízejí tak integrovanou asistenci."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Průměrné využití paměti"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maximální využití paměti"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Využití paměti"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Využití aplikací"</string>
    <string name="memory_details" msgid="6133226869214421347">"Podrobnosti"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"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="6708111974923274436">"Za poslední 3 hodiny nebyla využita žádná paměť."</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Řadit podle prům. využití"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Řadit podle max. využití"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Výkon"</string>
    <string name="total_memory" msgid="5244174393008910567">"Celková paměť"</string>
    <string name="average_used" msgid="690235917394070169">"Průměrně použito (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Volná"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Paměť používaná aplikacemi"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{V poslední době ({time}) využila paměť 1 aplikace}few{V poslední době ({time}) využily paměť # aplikace}many{V poslední době ({time}) využilo paměť # aplikace}other{V poslední době ({time}) využilo paměť # aplikací}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Frekvence"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maximální využití"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Nebyla využita žádná data"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"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="8468714854067428987">"Aplikace bude moci zapínat a vypínat režim Nerušit a měnit související nastavení."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Tato možnost musí zůstat zapnutá, protože je zapnut přístup k oznámením"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Odebrat aplikaci <xliff:g id="APP">%1$s</xliff:g> přístup k režimu Nerušit?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Všechna pravidla pro režim Nerušit vytvořená touto aplikací budou odstraněna."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Neoptimalizovat"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimalizovat"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Baterie se může vybíjet rychleji. Aplikace již nebude mít zakázáno využívat baterii na pozadí."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Doporučeno k zajištění delší výdrže baterie"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Žádná"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"I když této aplikaci vypnete přístup k informacím o využití, administrátor bude moci i nadále sledovat využití aplikací ve vašem pracovním profilu"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Zobrazení přes ostatní aplikace"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Zobrazení přes ostatní aplikace"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Povolit zobrazení přes jiné aplikace"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Když tuto možnost povolíte, aplikace se bude moci zobrazovat přes ostatní aplikace, které používáte. Aplikace uvidí, kam jste klepli, nebo změní, co je zobrazeno na obrazovce."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Přístup ke všem souborům"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Povolit přístup ke správě všech souborů"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Když tuto možnost povolíte, aplikace bude moci načítat, upravovat a mazat soubory v tomto zařízení a v připojených úložištích. Aplikace bude mít přístup k souborům i bez vašeho vědomí."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Mají přístup ke všem souborům"</string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Oznámení na celou obrazovku"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Povolte oznámení z této aplikace na celou obrazovku"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Povolte této aplikaci zobrazovat oznámení na celou obrazovku, když bude zařízení zamknuté. Aplikace tak mohou zvýraznit budíky, příchozí hovory a další důležitá oznámení."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Aplikace pro správu médií"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Povolit aplikaci spravovat média"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Když tuto možnost povolíte, aplikace bude moci bez zeptání upravovat a mazat mediální soubory vytvořené v jiných aplikacích. Aplikace musí mít oprávnění pro přístup k souborům a médiím."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Média, soubor, správa, správce, spravovat, upravovat, editor, aplikace, program"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"VR virtuální realita přijímač stereo pomocná služba"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Zobrazení přes ostatní aplikace"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Aplikace s oprávněním"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Povoleno"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Nepovoleno"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"instalace aplikace neznámé zdroje"</string>
    <string name="write_settings" msgid="6864794401614425894">"Změny nastavení systému"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"zápis a změna nastavení systému"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Lze nainstalovat jiné aplikace"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Smí měnit nastavení systému"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Smí měnit nastavení systému"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Změny nastavení systému"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Povolit úpravy nastavení systému"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Toto oprávnění umožňuje aplikaci měnit nastavení systému."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Povolit z tohoto zdroje"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Otevření Fotoaparátu otočením zápěstí"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Umožňuje otevřít aplikaci Fotoaparát dvojitým otočením zápěstí."</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Zobrazovaná velikost"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Všechno zvětšit nebo zmenšit"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"displej, hustota, přiblížení obrazovky, měřítko, zvětšení"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Náhled"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Zmenšit"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Zvětšit"</string>
    <string name="disconnected" msgid="3469373726996129247">"Nepřipojeno"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Nepřipojena"</string>
    <string name="apps_summary" msgid="4007416751775414252">"Nainstalované aplikace: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="storage_summary" msgid="5903562203143572768">"Využito: <xliff:g id="PERCENTAGE">%1$s</xliff:g>, volné místo: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tmavý motiv, velikost písma, jas"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Přibližné využití paměti: <xliff:g id="USED_MEMORY">%1$s</xliff:g> z <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="8473589474976307510">"Jste přihlášeni jako <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Aktualizováno na Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"K dispozici je aktualizace"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Blokováno pracovními zásadami"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Hlasitost nelze změnit"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Nelze uskutečňovat hovory"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Nelze posílat SMS"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Nelze používat fotoaparát"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Nelze pořizovat snímky obrazovky"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Tuto aplikaci nelze otevřít"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Blokováno vaším poskytovatelem kreditu"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Je potřeba rodič"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Dejte telefon rodiči, který vše nastaví"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Předejte telefon rodiči, aby povolil změnu tohoto nastavení."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Další informace vám poskytne váš administrátor IT."</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Další podrobnosti"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Administrátor může sledovat a spravovat aplikace a data přidružená k vašemu pracovnímu profilu, včetně nastavení, oprávnění, firemního přístupu, aktivity v síti a informací o poloze zařízení."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Administrátor může sledovat a spravovat aplikace a data přidružená k tomuto uživateli, včetně nastavení, oprávnění, firemního přístupu, aktivity v síti a informací o poloze zařízení."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Administrátor může sledovat a spravovat aplikace a data přidružená k tomuto zařízení, včetně nastavení, oprávnění, firemního přístupu, aktivity v síti a informací o poloze zařízení."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Administrátor vašeho zařízení má přístup k datům spojeným s tímto zařízením, může měnit jeho nastavení a spravovat aplikace."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Vypnout"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Zapnout"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Zobrazit"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Skrýt"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Hotspot je aktivní"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Režim Letadlo je zapnutý"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Sítě nejsou k dispozici"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Režim Nerušit je zapnutý"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Telefon je ztlumen"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"S výjimkami"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Spořič baterie je zapnutý"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Omezené funkce"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobilní data jsou vypnuta"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet je k dispozici jen přes Wi-Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Spořič dat"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Omezené funkce"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Pracovní profil je vypnutý"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Pro aplikace a oznámení"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Zapnout zvuk"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Vyzvánění bylo ztlumeno"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Volání a oznámení"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Pouze vibrace"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Volání a oznámení"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Nastavení plánu nočního režimu"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Každý večer automaticky zbarvit obrazovku do oranžova"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Noční režim je aktivní"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Tónování obrazovky do jantarové"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Zešednutí obrazovky"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Displej pouze v šedé barvě"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Sbalit"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Studené barvy"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Použijí se studenější barvy zobrazení"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Chcete-li změnu barev použít, vypněte obrazovku"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Laserový senzor fotoaparátu"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatické aktualizace systému"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Nainstalovat aktualizace po restartu zařízení"</string>
    <string name="usage" msgid="287782903846013936">"Využití"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Využití mobilních dat"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Využití dat aplikacemi"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Využití dat přes Wi-Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Využití dat mimo operátora"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Využití dat přes ethernet"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"Mobilní data: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"Data přes Wi-Fi: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"Data přes ethernet: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Limit dat a upozornění"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Cyklus využití mobilních dat"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Upozornění na data při <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Limit dat <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Upozornění na data: <xliff:g id="ID_1">^1</xliff:g> / limit dat: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Graf nezahrnuje data využitá sítěmi operátora."</string>
    <string name="data_used_template" msgid="8229342096562327646">"Využito <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Nastavit upozornění na data"</string>
    <string name="data_warning" msgid="2925054658166062884">"Upozornění na data"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Upozornění na data a limit dat měří zařízení. Tyto údaje se od údajů operátora mohou lišit."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Nastavit limit dat"</string>
    <string name="data_limit" msgid="8731731657513652363">"Limit dat"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"Využito <xliff:g id="ID_1">%1$s</xliff:g> (<xliff:g id="ID_2">%2$s</xliff:g>)"</string>
    <string name="configure" msgid="1499586749829665889">"Konfigurovat"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Ostatní aplikace zahrnuté do využití"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 aplikace má povoleno využívat neomezená data, i když je zapnutý Spořič dat}few{# aplikace mají povoleno využívat neomezená data, i když je zapnutý Spořič dat}many{# aplikace má povoleno využívat neomezená data, i když je zapnutý Spořič dat}other{# aplikací má povoleno využívat neomezená data, i když je zapnutý Spořič dat}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Primární data"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Data přes Wi‑Fi"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Využito <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"<xliff:g id="ID_1">^1</xliff:g> nad limit"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Zbývá: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Graf zobrazuje využití dat od <xliff:g id="START_DATE">%1$s</xliff:g> do <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Pro zadané období nejsou k dispozici žádná data"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{Zbývá # den}few{Zbývají # dny}many{Zbývá # dne}other{Zbývá # dní}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Nezbývá žádný čas"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Zbývá méně než 1 den"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Aktualizováno operátorem <xliff:g id="ID_1">^1</xliff:g> před <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Aktualizováno před <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Aktualizováno operátorem <xliff:g id="ID_1">^1</xliff:g> teď"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Aktualizováno teď"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Zobrazit podrobnosti"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Spořič dat"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Neomezená data"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Data na pozadí jsou vypnuta"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Zapnutý"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Vypnutý"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Používat spořič dat"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Neomezené využití dat"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Povolit neomezený přístup k datům, když je zapnutý Spořič dat"</string>
    <string name="home_app" msgid="6056850504746902747">"Vstupní aplikace"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Přidejte další otisk"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Odemknout jiným prstem"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Zapnuto"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Zapne se při <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>."</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Vypnutý"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Spotřeba baterie aplikacemi"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Nastavte spotřebu baterie aplikacemi"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Zobrazit nastavení"</string>
    <!-- no translation found for battery_tips_card_action_button_check (1535140204105479318) -->
    <skip />
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"Rozumím"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Je tahle zpráva užitečná?"</string>
    <!-- no translation found for battery_hints_warning_icon_a11y (5312542323401447620) -->
    <skip />
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Pokud chcete prodloužit výdrž baterie, zapněte adaptivní jas"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Pokud chcete prodloužit výdrž baterie, zkraťte interval vypnutí obrazovky"</string>
    <!-- no translation found for battery_tips_apps_summary_always_high (6334519477067044920) -->
    <skip />
    <!-- no translation found for battery_tips_apps_summary_higher_than_usual (95676961671544628) -->
    <skip />
    <!-- no translation found for battery_tips_apps_summary_always_high_in_background (2953858181710181126) -->
    <skip />
    <!-- no translation found for battery_tips_apps_summary_higher_than_usual_in_background (1585002072567422199) -->
    <skip />
    <!-- no translation found for battery_tips_apps_summary_always_high_in_foreground (1910991243576404700) -->
    <skip />
    <!-- no translation found for battery_tips_apps_summary_higher_than_usual_in_foreground (7937337570425168210) -->
    <skip />
    <!-- no translation found for battery_app_item_hint (4850929961461039110) -->
    <skip />
    <!-- no translation found for battery_app_item_hint_in_bg (596240821466388336) -->
    <skip />
    <!-- no translation found for battery_app_item_hint_in_fg (5091860632260799910) -->
    <skip />
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Neomezeno"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimalizováno"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Omezeno"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Výchozí kontrola pravopisu"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Výběr kontroly pravopisu"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Používat kontrolu pravopisu"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Nevybráno"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pkg"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"klíč"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"skupina"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(souhrn)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"publicVersion"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"důležitost"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"vysvětlení"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"může zobrazovat odznak"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"intent"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"smazání intentu"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"intent pro celou obrazovku"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"akce"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"nadpis"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"vzdálené vstupy"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"vlastní zobrazení"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"extra"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"velikost zásilky"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"bylo zobrazeno oznámení"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanál"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Objekt hodnocení chybí."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Objekt hodnocení tento klíč neobsahuje."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Výřez displeje"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"výřez displeje"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Výchozí nastavení zařízení"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Překrytí se nepodařilo použít"</string>
    <string name="special_access" msgid="1767980727423395147">"Speciální přístup aplikací"</string>
    <string name="special_access_more" msgid="132919514147475846">"Zobrazit více"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Dlouhé úkoly na pozadí"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Povolte dlouhé úkoly na pozadí"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Dlouhé úkoly na pozadí"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Povolte této aplikaci provádět dlouhé úkoly na pozadí. Tyto úkoly trvají déle než pár minut a jedná se např. o stahování a nahrávání. \n\nPokud oprávnění neudělíte, systém omezí, jak dlouho může aplikace provádět tyto úkoly na pozadí."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"dlouhodobé úlohy, přenos dat, úkoly na pozadí"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Resetovat limity četnosti služby ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Limity četnosti služby ShortcutManager byly resetovány"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Nastavte informace na obrazovce uzamčení"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Zobrazit nebo skrýt obsah oznámení"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Tipy a podpora"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Minimální šířka"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Žádné nainstalované aplikace o přístup k prémiovým SMS nepožádaly"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Prémiové SMS mohou být zpoplatněny a jejich cena se přičte k fakturaci operátora. Pokud aplikaci udělíte příslušné oprávnění, budete pomocí této aplikace moci odesílat prémiové SMS."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Přístup k prémiovým SMS"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Vypnuto"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Připojeno k zařízení <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Připojeno k několika zařízením"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Ukázkový režim uživatelského rozhraní systému"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tmavý motiv"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Dočasně deaktivováno spořičem baterie"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Dočasně deaktivováno spořičem baterie"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Vypnutí spořiče baterie"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Dočasně vypnuto spořičem baterie"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Vyzkoušet tmavý motiv"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Pomáhá prodloužit výdrž baterie"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Dlaždice rychlého nastavení pro vývojáře"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Vypnout časový limit autorizací adb"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Vypnout automatické zrušení autorizací adb u systémů, které se nepřipojily do výchozí (7 dní) nebo uživatelem nastavené doby (minimálně 1 den)."</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Senzory jsou vypnuty"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Nastavení pracovního profilu"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Vyhledávat kontakty z pracovního adresáře v osobních aplikacích"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Vaše vyhledávání a příchozí hovory se možná zobrazí administrátorovi IT."</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kalendář s více profily"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Zobrazovat v osobním kalendáři pracovní události"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Když jsou pracovní aplikace vypnuté, jsou pozastaveny, nelze je otevřít a nemohou vám ani zasílat oznámení."</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Správa úložiště"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Správce úložiště vám pomůže uvolnit místo v úložišti tím, že ze zařízení odstraní zálohované fotky a videa."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Odstranit fotky a videa"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Správce úložiště"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Používat správce úložiště"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gesta"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Rychle otevřít fotoaparát"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Pokud chcete rychle spustit fotoaparát, stiskněte dvakrát vypínač. Funguje to na všech obrazovkách."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Přepnout fotoaparát na selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Režim navigace"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigace dvěma tlačítky"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Mezi aplikacemi přepnete přejetím prstem nahoru po tlačítku plochy. Všechny aplikace zobrazíte opětovným přejetím prstem nahoru. Zpět se vrátíte klepnutím na tlačítko Zpět."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Bezpečnost a stav nouze"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Tísňové volání, zdravotní údaje, upozornění"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigace gesty"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"Pokud chcete přejít na plochu, přejeďte ze spodní části obrazovky nahoru. Aplikace přepnete přejetím prstem zdola nahoru, podržením obrazovky a uvolněním prstu. Zpět se vrátíte přejetím prstem z levého nebo pravého okraje obrazovky."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navigace třemi tlačítky"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"K přechodu zpět, zobrazení plochy a přepínání mezi aplikacemi slouží tlačítka v dolní části obrazovky."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"systémová navigace, navigace dvěma tlačítky, navigace třemi tlačítky, navigace gesty, přejetí prstem"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digitální asistent"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Vyvolat asistenta přejetím prstem"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Aplikaci digitálního asistenta vyvoláte přejetím prstem nahoru ze spodního rohu obrazovky."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Aktivovat Asistenta podržením tlačítka plochy"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Aplikaci digitálního asistenta vyvoláte podržením tlačítka plochy."</string>
    <string name="low_label" msgid="6525629096999711220">"Nízká"</string>
    <string name="high_label" msgid="357503396626018487">"Vysoká"</string>
    <string name="left_edge" msgid="1513576842959071849">"Levý okraj"</string>
    <string name="right_edge" msgid="1505309103265829121">"Pravý okraj"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Vyšší citlivost může narušovat gesta v aplikacích prováděná u okrajů obrazovky."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Citlivost na zpětné gesto"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Citlivost navigace gesty"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Navigace tlačítky"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigace gesty, citlivost na zpětné gesto, zpětné gesto"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigace, tlačítko plochy"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Režim jedné ruky"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Používat režim jedné ruky"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Zkratka pro režim jedné ruky"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"dosažitelnost"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Přejetím dolů:"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Použití této zkratky"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Stáhněte dolů horní polovinu obrazovky, abyste na ni snáze dosáhli jednou rukou"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Jak používat režim jedné ruky"</b>\n" • V nastavení systémové navigace musí být vybrána navigace gesty\n • U spodního okraje obrazovky přejeďte prstem dolů"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Přitáhnout obrazovku na dosah"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Horní část obrazovky se přesune na dosah vašeho palce."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Zobrazit oznámení"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Zobrazí se oznámení a nastavení."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Chcete-li zobrazit čas, oznámení a další informace, dvakrát klepněte na obrazovku."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Zobrazení po probuzení"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Klepnutím na obrazovku si zobrazíte čas, oznámení a další informace."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Tísňové volání"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Použití tísňového volání"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Stisknutím vypínače rychle alespoň pětkrát za sebou spustíte níže uvedené akce"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Přehrát upozornění na odpočet"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Před tísňovým voláním přehrát hlasitý zvuk"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Volání o pomoc"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Zavolat pomoc"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Číslo, na které můžete zavolat o pomoc"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Klepnutím změníte"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Pokud zadáte linku, která není tísňová:\n • Tísňové volání budete moci použít pouze v případě, že zařízení bude odemčené\n • Je možné, že hovor nikdo nepřijme"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Zobrazit oznámení otiskem prstu"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Sejmutí otisku prstu"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Zobrazujte oznámení rychle"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Zapnuto"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Vypnuto"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Zavaděč je již odemknut"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Připojte se k internetu nebo kontaktujte operátora"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Není k dispozici v zařízeních uzamčených operátorem"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Chcete-li aktivovat ochranu, restartujte zařízení."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Uvolněno celkem <xliff:g id="SIZE">%1$s</xliff:g>\n\nNaposledy spuštěno <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Okamžité aplikace"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Otevírat odkazy v aplikacích, i když nejsou nainstalované"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Okamžité aplikace"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Předvolby okamžitých aplikací"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Nainstalované aplikace"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Úložiště je teď spravováno správcem úložiště."</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Účty uživatele <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Automaticky synchronizovat data aplikací"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Nechat aplikace automaticky aktualizovat data"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Synchronizace účtů"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Synchronizace je zapnuta u <xliff:g id="ID_1">%1$d</xliff:g> z <xliff:g id="ID_2">%2$d</xliff:g> položek"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Synchronizace je zapnuta u všech položek"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Synchronizace je vypnuta u všech položek"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Informace o spravovaném zařízení"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Změny a nastavení spravuje organizace"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Změny a nastavení spravuje organizace <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Za účelem zpřístupnění pracovních dat vám organizace může změnit nastavení a nainstalovat do zařízení software.\n\nDalší podrobnosti vám sdělí administrátor organizace."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Typy informací, které vidí vaše organizace"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Změny, které provedl administrátor vaší organizace"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Váš přístup k tomuto zařízení"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Data přidružená k vašemu pracovnímu účtu, jako je například e-mail a kalendář"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Seznam aplikací ve vašem zařízení"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Doba používání jednotlivých aplikací a množství jimi využitých dat"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Nejnovější protokol síťového provozu"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Nejnovější zpráva o chybě"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Nejnovější protokol zabezpečení"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Žádné"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Nainstalované aplikace"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Počet aplikací je odhad. Nemusí zahrnovat aplikace nainstalované mimo Obchod Play."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Minimálně # aplikace}few{Minimálně # aplikace}many{Minimálně # aplikace}other{Minimálně # aplikací}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Oprávnění přístupu k poloze"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Oprávnění přístupu k mikrofonu"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Oprávnění přístupu k fotoaparátu"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Výchozí aplikace"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# aplikace}few{# aplikace}many{# aplikace}other{# aplikací}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Výchozí klávesnice"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Nastaveno na <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Trvalá síť VPN je zapnutá"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Trvalá síť VPN je zapnutá v osobním profilu"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Trvalá síť VPN je zapnutá v pracovním profilu"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Globální proxy server protokolu HTTP je nastaven"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Důvěryhodné identifikační údaje"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Důvěryhodné identifikační údaje ve vašem osobním profilu"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Důvěryhodné identifikační údaje ve vašem pracovním profilu"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Minimálně # certifikát CA}few{Minimálně # certifikáty CA}many{Minimálně # certifikátu CA}other{Minimálně # certifikátů CA}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Administrátor může zařízení uzamknout a resetovat heslo"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administrátor může smazat všechna data v zařízení"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Nezdařené pokusy o zadání hesla před smazáním veškerých dat v zařízení"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Nezdařené pokusy o zadání hesla před smazáním dat z pracovního profilu"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# pokus}few{# pokusy}many{# pokusu}other{# pokusů}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Toto zařízení spravuje vaše organizace."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Toto zařízení je spravováno organizací <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Další informace"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Omezené nastavení"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Pro aplikaci <xliff:g id="APP_NAME">%s</xliff:g> byla povolena omezená nastavení"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Z důvodu vaší bezpečnosti toto nastavení momentálně není dostupné."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Informace o financovaném zařízení"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Poskytovatel úvěru může v tomto zařízení během úvodního nastavování měnit nastavení a instalovat do něj software.\n\nV případě neuhrazení splátky může poskytovatel úvěru uzamknout zařízení a změnit nastavení.\n\nDalší informace vám sdělí poskytovatel úvěru."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Pokud je zařízení financováno úvěrem, nemůžete:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Instalovat aplikace mimo Obchod Play"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Restartovat zařízení do nouzového režimu"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Přidat do zařízení několik uživatelů"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Změnit datum, čas a časová pásma"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Používat nastavení pro vývojáře"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Poskytovatel úvěru může:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Přistupovat k číslu IMEI"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Obnovit zařízení do továrního nastavení, pokud se něco pokazilo"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Pokud je zařízení zamknuté, můžete pomocí něj pouze:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Volat na tísňové linky"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Zobrazit systémové informace, jako je datum, čas, stav sítě a baterie"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Zapnout nebo vypnout zařízení"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Zobrazit oznámení a textové zprávy"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Přistupovat k aplikacím, které poskytovatel úvěru povolil"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Po zaplacení celé částky:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Ze zařízení jsou odstraněna všechna omezení"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Aplikaci věřitele můžete odinstalovat"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Informace o financovaném zařízení"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Aplikace k focení a natáčení}few{Aplikace k focení a natáčení}many{Aplikace k focení a natáčení}other{Aplikace k focení a natáčení}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Kalendářová aplikace"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Aplikace pro kontakty"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{Aplikace pro práci s e‑maily}few{Aplikace pro práci s e‑maily}many{Aplikace pro práci s e‑maily}other{Aplikace pro práci s e‑maily}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Mapová aplikace"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Aplikace k telefonování}few{Aplikace k telefonování}many{Aplikace k telefonování}other{Aplikace k telefonování}}"</string>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="7019703249717854148">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_default_internal_storage" msgid="4055660218818688131">"Toto zařízení"</string>
    <string name="storage_games" msgid="1176568610086802469">"Hry"</string>
    <string name="storage_files" msgid="7968460921272772299">"Soubory"</string>
    <string name="storage_images" msgid="2055893015567979387">"Obrázky"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videa"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Zvuk"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Aplikace"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumenty a další"</string>
    <string name="storage_system" msgid="8472410119822911844">"Systém"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Koš"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Vysypat koš?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"V koši je tento počet souborů: <xliff:g id="TOTAL">%1$s</xliff:g>. Všechny položky budou navždy smazány a nebude možné je obnovit."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Koš je prázdný"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Vysypat koš"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"Využito <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Celkem <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Vymazat aplikaci"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Chcete tuto okamžitou aplikaci odstranit?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Otevřít"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Hry"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Využité místo"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(pro uživatele <xliff:g id="USER">%s</xliff:g> odinstalováno)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(pro uživatele <xliff:g id="USER">%s</xliff:g> nedostupné)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Služba automatického vyplňování"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Výchozí služba automatického vyplňování"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Hesla"</string>
    <string name="credman_chosen_app_title" msgid="872524130208251505">"Hesla, přístupové klíče a datové služby"</string>
    <string name="credman_credentials" msgid="4931371941253324143">"Další poskytovatelé"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# heslo}few{# hesla}many{# hesla}other{# hesel}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automaticky, vyplnit, vyplnit automaticky, heslo"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"data, přístupový klíč, heslo"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"automatické, vyplňování, automatické vyplňování, údaje, přístupový klíč, heslo"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Zkontrolujte, zda se jedná o důvěryhodnou aplikaci&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Automatické doplňování Google&gt;%1$s&lt;/xliff:g&gt; určuje, co lze automaticky vyplnit, na základě obsahu obrazovky."</string>
    <string name="credman_autofill_confirmation_message" msgid="4951846866327737417">"&lt;b&gt;Použít &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; používá obsah obrazovky k určení, co lze automaticky vyplnit. Odteď se sem budou ukládat nová hesla, přístupové klíče a další údaje."</string>
    <string name="credman_picker_title" msgid="8191267620665129205">"Hesla, přístupové klíče a datové služby"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Vypnout poskytovatele %1$s?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Vypnout tuto službu?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Při přihlášení se nebudou vyplňovat uložené údaje, jako jsou hesla, přístupové klíče, platební metody a podobně. Pokud chcete používat uložené údaje, zvolte heslo, přístupový klíč nebo datovou službu."</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Použít %1$s?"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s určuje údaje, které lze automaticky vyplnit, na základě obsahu obrazovky."</string>
    <string name="credman_error_message_title" msgid="4099557206946333568">"Limit hesel, přístupových klíčů a datových služeb"</string>
    <string name="credman_error_message" msgid="8334797097200415449">"V jednu chvíli můžete mít aktivních až 5 hesel, přístupových klíčů a datových služeb. Pokud chcete přidat další, některou službu vypněte."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Vypnout"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Automatické vyplňování"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Úroveň protokolování"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Maximální počet požadavků na relaci"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Maximální počet viditelných datových sad"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Resetovat na výchozí hodnoty"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Možnosti automatického vyplňování pro vývojáře byly resetovány"</string>
    <string name="location_category" msgid="3496759112306219062">"Poloha"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Indikátor polohy na stavovém řádku"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Zobrazit u všech poloh (včetně polohy zjištěné ze sítě a připojení)"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Vynutit úplné měření GNSS"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Sledovat všechny konstelace a frekvence GNSS bez cyklického vypínání a zapínání"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Metoda zadávání dat"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Psaní dotykovým perem"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Když je tato možnost zapnutá, aktuální metoda zadávání dostane v případě výběru editoru objekt MotionEvent z dotykového pera."</string>
    <string name="device_theme" msgid="5027604586494772471">"Motiv zařízení"</string>
    <string name="default_theme" msgid="4815428567082263639">"Výchozí"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Název sítě"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Zobrazovat název sítě na stavovém řádku"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Okamžitá aplikace"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Chcete vypnout správce úložiště?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Aktualizujte režim Nerušit"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pokud nechcete být rušeni, oznámení pozastavte"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funkce není k dispozici"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Tato funkce byla vypnuta, protože zpomaluje telefon"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Vždy zobrazit dialog o pádu"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Zobrazí dialog při každém pádu aplikace"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Vyberte aplikaci podporující ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Není nastavena žádná aplikace podporující ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Aplikace podporující ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Předvolby ovladače grafiky"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Upravit nastavení ovladače grafiky"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Když je zapnuto několik ovladačů grafiky, můžete pro aplikace nainstalované v zařízení používat aktualizovaný ovladač grafiky."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Zapnout pro všechny aplikace"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Vyberte ovladač grafiky"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Výchozí"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Herní ovladač"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Ovladač pro vývojáře"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Systémový ovladač grafiky"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="enable_angle_as_system_driver" msgid="3985105681812713612">"Povolit ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="6413038127558166972">"Povolit ANGLE jako výchozí ovladač OpenGL ES. Pokud ho povolíte na nekompatibilním zařízení, některé aplikace mohou přestat fungovat."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Změna systémového ovladače OpenGL ES vyžaduje restart"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Změny kompatibility aplikací"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Přepínat změny kompatibility aplikací"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Změny, které jsou ve výchozím nastavení povoleny"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Změny, které jsou ve výchozím nastavení zakázány"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Kompatibilitu lze upravovat pouze u laditelných aplikací. Nainstalujte laditelnou aplikaci a zkuste to znovu."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Závisí na jiném nastavení"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Účet"</string>
    <string name="my_device_info_account_preference_summary" msgid="3510582677937510545">"Účty: %d"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Název zařízení"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Základní informace"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Právní předpisy"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Podrobnosti o zařízení"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Identifikátory zařízení"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Ovládání sítí Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Povolit aplikaci ovládat Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Jestliže tuto možnost povolíte, aplikace bude moci zapínat a vypínat Wi-Fi, vyhledávat sítě Wi-Fi a připojovat se k nim, přidávat nebo odstraňovat sítě nebo nastavit místní hotspot."</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Spouštění přes NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Povolit spuštění při naskenování NFC"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Povolit spuštění této aplikace při naskenování štítku NFC.\nPokud je toto oprávnění zapnuté, aplikace bude dostupná jako možnost při každém rozpoznání štítku."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Kde přehrávat média"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Pustit <xliff:g id="LABEL">%s</xliff:g> přes"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Toto zařízení"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Při volání nedostupné"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Přijmout hovor v zařízení"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Tento APN nelze změnit."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Deaktivovat vyzvánění"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Současné stisknutí vypínače a tlačítka zvýšení hlasitosti umožní:"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Zkratka k vypnutí vyzvánění"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibrovat"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Vypnout zvuk"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibrace"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Vypnout zvuk"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Pokud chcete zapnout tuto možnost, nejdříve změňte akci přidruženou k podržení vypínače tak, aby se jím otevírala nabídka vypínače."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Podrobnosti sítě"</string>
    <string name="devices_title" msgid="649715719278562515">"Zařízení"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Vybrat síť"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Odpojeno"</string>
    <string name="network_connected" msgid="7637745547242487795">"Připojeno"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Připojování…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Nelze se připojit"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Žádná síť nebyla nalezena."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Nebyla nalezena žádná síť. Zkuste to znovu."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(zakázáno)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Žádná SIM karta"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Žádné"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"K připojení vyžaduje SIM kartu"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"K připojení vyžaduje SIM kartu <xliff:g id="WIRELESS_CARRIER">%s</xliff:g>"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Preferovaný režim sítě: preferováno WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Preferovaný režim sítě: pouze GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Preferovaný režim sítě: pouze WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Preferovaný režim sítě: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Preferovaný režim sítě: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Preferovaný režim sítě: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Preferovaný režim sítě: pouze CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Preferovaný režim sítě: pouze EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Preferovaný režim sítě: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Preferovaný režim sítě: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Preferovaný režim sítě: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Preferovaný režim sítě: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Preferovaný režim sítě: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Preferovaný režim sítě: Globální"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Preferovaný režim sítě: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Preferovaný režim sítě: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Preferovaný režim sítě: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Preferovaný režim sítě: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Preferovaný režim sítě: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Preferovaný režim sítě: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Preferovaný režim sítě: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Preferovaný režim sítě: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Preferovaný režim sítě: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Preferovaný režim sítě: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Preferovaný režim sítě: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Preferovaný režim sítě: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Preferovaný režim sítě: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Preferovaný režim sítě: pouze NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Preferovaný režim sítě: NR / LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Preferovaný režim sítě: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Preferovaný režim sítě: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Preferovaný režim sítě: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Preferovaný režim sítě: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Preferovaný režim sítě: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Preferovaný režim sítě: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Preferovaný režim sítě: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Preferovaný režim sítě: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Preferovaný režim sítě: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (doporučeno)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (doporučeno)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (doporučeno)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Vybírat síť automaticky"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Nastavení operátora"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Nastavit datovou službu"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobilní data"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Používat datové připojení přes mobilní síť"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefon se v dosahu automaticky přepne na tohoto operátora"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Není k dispozici žádná SIM karta"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Předvolby hovorů"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Předvolby SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Pokaždé se zeptat"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Přidat síť"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Výchozí pro hovory"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Výchozí pro SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Výchozí pro hovory a SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Výchozí pro mobilní data"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobilní data jsou aktivní"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobilní data jsou vypnuta"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Dostupné"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Přidat SIM kartu"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktivní / SIM karta"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Neaktivní / SIM karta"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Aktivní / eSIM karta"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Neaktivní / eSIM karta"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Název a barva SIM karty"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Název"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Barva (používají kompatibilní aplikace)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Uložit"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Používat SIM kartu"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Vypnuto"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Chcete-li tuto SIM kartu deaktivovat, vyjměte ji"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Klepnutím aktivujte operátora <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Vymazat SIM kartu"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Preferovaný typ sítě"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Změnit provozní režim sítě"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Preferovaný typ sítě"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Verze nastavení operátora"</string>
    <string name="call_category" msgid="641461844504128789">"Volání"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Videohovory přes operátora"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Výběr systému"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Změnit režim roamingu CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Výběr systému"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Síť"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Odběr CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Přepnout mezi RUIM/SIM a NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"odběr"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automatická registrace…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Povolit datový roaming?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Ceny vám sdělí poskytovatel datových služeb."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Využití dat aplikacemi"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Neplatný režim sítě <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignorovat."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Názvy přístupových bodů"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Při připojení k operátorovi <xliff:g id="CARRIER">%1$s</xliff:g> nedostupné"</string>
    <string name="see_more" msgid="7499355691042812723">"Zobrazit další"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Zapnout operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Zapnout SIM kartu?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Přepnout na operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Přepnout na SIM kartu?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Použít operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"V jednu chvíli může být aktivní pouze jedna SIM karta.\n\nPřepnutím na operátora <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> nezrušíte službu <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"V jednu chvíli může být aktivní pouze jedna SIM karta.\n\nPřepnutím na operátora <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> nezrušíte tarif u operátora <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"V jednu chvíli může být aktivní pouze jedna SIM karta.\n\nPřepnutím nezrušíte službu <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Můžete používat dvě SIM karty současně. Pokud chcete použít operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, vypněte jinou SIM."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Přepnout na síť <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off" msgid="5392037608705799522">"Vypnout operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Vypnutím SIM karty nezrušíte svůj tarif."</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Připojování k síti…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Přepínání na operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g> pro hovory a zprávy…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Operátora nelze přepnout"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Operátora kvůli chybě nelze přepnout."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Vypnout operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Vypnout SIM kartu?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Vypínání SIM karty<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Operátora nelze deaktivovat"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Něco se pokazilo a deaktivace operátora se nezdařila."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Používat dvě SIM karty?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"V tomto zařízení lze používat dvě SIM karty současně. Pokud chcete používat jen jednu, klepněte na „Ne, díky“."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Restartovat zařízení?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Ano"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Restartovat"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Ne, díky"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Zrušit"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Přepnout"</string>
    <string name="sim_action_turn_off" msgid="3506698692916473000">"Vypnout"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"SIM kartu nelze aktivovat"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Zkuste SIM kartu znovu zapnout. Pokud problém přetrvává, restartujte zařízení."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Aktivace sítě"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Přepnutí operátora"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"Číslo <xliff:g id="CARRIER_NAME">%1$s</xliff:g> je aktivní"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Klepnutím aktualizujete nastavení SIM karty"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Přepnuto na operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Přepnuto na jiného operátora"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Mobilní síť se změnila"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Nastavte druhou SIM kartu"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Vyberte aktivní SIM kartu nebo použijte dvě SIM karty naráz"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Vyberte číslo, které chcete použít"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{V zařízení je k dispozici 1 číslo, ale v jednu chvíli lze použít jen jedno}=2{V zařízení jsou k dispozici 2 čísla, ale v jednu chvíli lze použít jen jedno}few{V zařízení jsou k dispozici # čísla, ale v jednu chvíli lze použít jen jedno}many{V zařízení je k dispozici # čísla, ale v jednu chvíli lze použít jen jedno}other{V zařízení je k dispozici # čísel, ale v jednu chvíli lze použít jen jedno}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Probíhá aktivace<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Teď nelze aktivovat"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Použít operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"Číslo <xliff:g id="CARRIER_NAME">%1$s</xliff:g> se bude používat pro mobilní data, volání a SMS."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Nejsou k dispozici žádné aktivní SIM karty"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Pokud budete chtít později používat mobilní data, volání a SMS, přejděte do nastavení sítě"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM karta"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Vymazat tuto eSIM kartu?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Když vymažete tuto SIM kartu, ze zařízení bude odebrána služba operátora <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g>.\n\nNeznamená to však, že služba operátora <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> bude zrušena."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Vymazat"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Mazání SIM karty…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"SIM kartu nelze vymazat"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Tuto SIM kartu nelze vymazat z důvodu chyby.\n\nRestartujte zařízení a zkuste to znovu."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Připojení k zařízení"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Aplikace <xliff:g id="APPNAME">%1$s</xliff:g> chce za účelem připojení k zařízení použít dočasnou síť Wi-Fi"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Nebyla nalezena žádná zařízení. Zajistěte, aby zařízení byla zapnutá a dostupná k připojení."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Zkusit znovu"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Něco se stalo. Aplikace zrušila požadavek na výběr zařízení."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Připojení úspěšně navázáno"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Připojení se nezdařilo"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Zobrazit vše"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Vyhledávání zařízení…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Připojování k zařízení…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Levé"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Pravé"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Hlavní díl"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Panel nastavení"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Vynutit režim počítače"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Na sekundárních displejích vynutí experimentální režim počítače"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Aktivovat neměnnou velikost v režimu několika oken"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Povolí aplikace s neměnnou velikostí v režimu několika oken"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Přepsat vynucení tmavého režimu"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Přepíše vynucení stálého zapnutí tmavého režimu"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Ochrana soukromí"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Oprávnění, aktivita na účtu, osobní údaje"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Ovládací prvky"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Odstranit"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Ponechat"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Odstranit tento návrh?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Málo místa. Využito: <xliff:g id="PERCENTAGE">%1$s</xliff:g> – volné: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Odeslat zpětnou vazbu"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Chtěli byste nám k tomuto návrhu poskytnout zpětnou vazbu?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> – zkopírováno do schránky"</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Využití přístupnosti"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 aplikace má plný přístup k vašemu zařízení}few{# aplikace mají plný přístup k vašemu zařízení}many{# aplikace má plný přístup k vašemu zařízení}other{# aplikací má plný přístup k vašemu zařízení}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Důležité informace"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"POKRAČOVAT"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NE, DĚKUJI"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Místo"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Při používání této služby k tísňovým voláním může váš operátor shromažďovat údaje o vaší poloze.\n\nPodrobnosti naleznete v zásadách ochrany soukromí operátora."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Ke zbývajícímu času nebo datům můžete ztratit přístup. Před odstraněním se informujte u operátora."</string>
    <string name="content_capture" msgid="868372905432812238">"Obsah aplikace"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Povolit aplikacím odesílat obsah do systému Android"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Zaznamenávat výpis haldy systému"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Memory Tagging Extension"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Funkce MTE (Memory Tagging Extension) usnadňuje zjišťování bezpečnostních problémů s pamětí v aplikaci a zajišťuje bezpečnější nativní kód aplikace."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Zapnutí funkce MTE může způsobit pomalejší výkon zařízení."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Další informace o funkci MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Aktivovat funkci MTE, dokud ji nevypnete"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Pokud chcete funkci MTE zapnout, musíte restartovat zařízení."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Pokud chcete funkci MTE vypnout, musíte restartovat zařízení."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Aktivovat funkci MTE v jedné relaci"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Systém se restartuje a bude možné experimentovat s technologií Memory Tagging Extension (MTE). Technologie MTE může nepříznivě ovlivnit výkon a stabilitu systému. Při dalším restartu se nastavení resetuje."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Restartováním zahájíte jednu relaci s aktivovanou funkcí MTE"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"Funkce MTE již je aktivovaná"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Zaznamenávání výpisu haldy systému"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Výpis haldy systému se nepodařilo získat"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Automaticky zaznamenávat výpisy haldy systému"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Automaticky zaznamenat výpis haldy systému Android, když bude využívat příliš mnoho paměti"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Odpojit"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Tísňová volání"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Tísňová volání pomocí funkce volání přes Wi-Fi váš operátor nepodporuje.\nZařízení se automaticky přepne na mobilní síť, aby mohlo provést tísňové volání.\nTísňová volání lze uskutečnit jen v oblastech s mobilním signálem."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Používat k volání připojení Wi-Fi s cílem zvýšit kvalitu"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Záložní volání"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Pokud <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> není k dispozici nebo vyžaduje roaming, použije se k hovorům přes <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g> SIM karta na mobilní data."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"záložní volání"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Příchozí zpráva MMS"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Zprávu MMS se nepodařilo odeslat"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Klepnutím povolíte zprávy MMS u operátora <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> při vypnutých mobilních datech"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"Zpráva MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problém s kombinací SIM karet"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Použití operátora <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> může omezit funkce. Klepnutím zobrazíte další informace."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Kombinace SIM karet"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informace o pracovních zásadách"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Nastavení spravováno administrátorem IT"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Nástroj pro zprávy o chybách"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Určuje, která aplikace na vašem zařízení zpracovává zkratku k odeslání zprávy o chybě."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Osobní"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Práce"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Výchozí nastavení systému"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Žádné"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Tato volba již není platná. Zkuste to znovu."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Podržení vypínače"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Podržením vypínače se otevře:"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Nabídka vypínače"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Digitální asistent"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Aktivace digitálního asistenta"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Otevření nabídky vypínače"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Před použitím nejdříve nastavte zámek obrazovky"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Nabídka vypínače:\nStiskněte současně vypínač a tlačítko zvýšení hlasitosti."</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Vypnutí vyzvánění:\nStiskněte tlačítko hlasitosti pro zkratku"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Délka podržení"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Citlivost nastavíte úpravou délky podržení vypínače"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Krátké"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Dlouhé"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Zobrazit peněženku"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Umožňuje přístup k peněžence z obrazovky uzamčení"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Zobrazit čtečku QR kódů"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Povolit přístup ke čtečce QR kódů na obrazovce uzamčení"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Zobrazit ovládací prvky zařízení"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Z obrazovky uzamčení"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Použít ovládání zařízení"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Nejprve zapněte zobrazení ovládání zařízení"</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"Velikost hodin se mění podle obsahu obrazovky uzamčení"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Dynamické hodiny"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Zkratky"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="few"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="many"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="one"><xliff:g id="FIRST_0">%1$s</xliff:g></item>
    </plurals>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Vypnout VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Touto akcí vypnete také připojení 5G.\nBěhem hlasového hovoru nemůžete používat internet a některé aplikace nemusí fungovat."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Pozastavit spouštění aplikací z mezipaměti"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Neomezená platnost."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Pronájem nikdy vyprší."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Povolit překryvné vrstvy obrazovek v Nastavení"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Povolte aplikace, které se smí zobrazovat přes jiné aplikace a vytvářet vrstvy obrazovek Nastavení"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Povolit simulovaný modem"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Povolte tomuto zařízení používat službu simulovaného modemu pro účely instrumentačního testu. Během běžného používání telefonu tuto možnost nepovolujte"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Média"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Připnout přehrávač médií"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Přehrávač médií zůstane otevřený v Rychlém nastavení, aby bylo možné rychle obnovit přehrávání"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Zobrazovat média na obrazovce uzamčení"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Přehrávač médií zůstane otevřený na obrazovce uzamčení, aby bylo možné rychle obnovit přehrávání"</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Zobrazovat doporučení médií"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Na základě vaší aktivity"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Skrýt přehrávač"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Zobrazit přehrávač"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"média"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Zapne se Bluetooth"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM karty"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Volání a SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Volání přes Wi-Fi"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Uskutečňujte a přijímejte hovory přes Wi-Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Volání"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"preferováno"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"preferováno pro hovory"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"preferováno pro SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"není k dispozici"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Dočasně nedostupné"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Žádná SIM karta"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Nastavení sítě"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"připojení k síti, internet, bezdrátové, data, wifi, wi-fi, wi fi, mobilní síť, mobilní operátor, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Resetovat internet?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Resetování internetu…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Opravit připojení"</string>
    <string name="networks_available" msgid="3299512933684383474">"Sítě jsou k dispozici"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Pokud chcete přepnout sítě, odpojte ethernet"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"Připojení W+"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Povolte službě Google Fi používat sítě W+ k vylepšení rychlosti a pokrytí"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"Síť W+"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"eSIM karta"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"eSIM karty"</string>
    <string name="sim_category_active_sim" msgid="1503823567818544012">"Aktivní"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Neaktivní"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Výchozí pro <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"hovory"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"mobilní data"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Za účelem lepšího fungování zařízení mohou aplikace a služby vyhledávat sítě Wi-Fi, i když je připojení Wi-Fi vypnuté. Lze tak vylepšit funkce a služby závislé na poloze. Toto chování můžete změnit v nastavení vyhledávání Wi-Fi."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Změnit"</string>
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g> / <xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Připojeno"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Dočasně připojeno"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Dočasně se používá <xliff:g id="SUBNAME">%1$s</xliff:g>"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Žádné připojení"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Mobilní data se nebudou připojovat automaticky"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Vypnout mobilní data?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Prostřednictvím <xliff:g id="CARRIER">%s</xliff:g> nebudete moci používat data ani internet. Internet bude dostupný pouze přes Wi-Fi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"vašeho operátora"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Není povoleno vaší organizací"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Nedostupné, protože je zapnutý režim nočního klidu"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Reset důležitosti oznámení byl dokončen."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Aplikace"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Zařízení žádá o přístup k vašim zprávám. Podrobnosti zobrazíte klepnutím."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Chcete povolit přístup ke zprávám?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Zařízení Bluetooth <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> žádá o přístup k vašim zprávám.\n\nK zařízení <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> jste se ještě nikdy nepřipojili."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Zařízení žádá o přístup k vašim kontaktům a seznamu hovorů. Podrobnosti zobrazíte klepnutím."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Chcete povolit přístup ke kontaktům a seznamu hovorů?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Zařízení Bluetooth <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> žádá o přístup k vašim kontaktům a seznamu hovorů. To zahrnuje data o příchozích a odchozích hovorech.\n\nK zařízení <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> jste se ještě nikdy nepřipojili."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Jas"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Obrazovka v uzamčeném režimu"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Vzhled"</string>
    <string name="category_name_color" msgid="937514550918977151">"Barva"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Další ovládací prvky obrazovky"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Obecné"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Používat tmavý motiv"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Používat Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Blokovat vyzvánění"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Používat hotspot sítě Wi‑Fi"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Používat připnutí aplikace"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Používat nastavení pro vývojáře"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Používat tiskovou službu"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Povolit více uživatelů"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"povolit, několik, uživatel, mnoho"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Používat bezdrátové ladění"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Použít nastavení ovladače grafiky"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Používat noční režim"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Používat NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Používat adaptivní jas"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Použít volání přes Wi-Fi"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Zobrazit všechny aplikace"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Chytré přesměrování"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Chytré přesměrování je aktivováno"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Chytré přesměrování není aktivováno"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Nastavení hovorů"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Probíhá aktualizace nastavení…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Chyba nastavení hovorů"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Došlo k chybě sítě nebo SIM karty."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM karta není aktivována."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Zadejte telefonní čísla"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Zadejte telefonní číslo"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Chybí telefonní číslo."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"OK"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Povolit 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"Připojení 2G je méně bezpečné, ale v některých oblastech může zlepšit kvalitu připojení. Pro tísňová volání je připojení 2G vždy zapnuté."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"Operátor <xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> vyžaduje připojení 2G"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Vyžadovat šifrování"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Šifrování je bezpečnější, ale na některých místech se možná nebudete moci připojit. U tísňových volání se šifrování nikdy nevyžaduje."</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Všechny služby"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Zobrazovat použití schránky"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Zobrazovat zprávu, když aplikace použijí text, obrázky nebo jiný obsah, který jste zkopírovali"</string>
    <string name="all_apps" msgid="3054120149509114789">"Všechny aplikace"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Nepovolovat"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultra-WideBand (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Pomáhá zjistit relativní pozici okolních zařízení, která podporují UWB"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Pokud chcete používat technologii UWB, vypněte režim Letadlo"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB v aktuální lokalitě není k dispozici"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Přístup k fotoaparátu"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Přístup k mikrofonu"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Aplikace a služby"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Týká se aplikací a služeb. Pokud je toto nastavení vypnuté a zavoláte na číslo tísňového volání, data z mikrofonu se mohou stále sdílet."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Předchozí"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Další"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Náhled barvy"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Žádost o přístup k SIM kartě"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Zařízení žádá o přístup k vaší SIM kartě. Podrobnosti zobrazíte klepnutím."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Povolit přístup k SIM kartě?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Zařízení Bluetooth <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> žádá o přístup k datům na vaší SIM kartě. Tato data zahrnují i vaše kontakty.\n\nBěhem připojení bude zařízení <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> přijímat všechny hovory směrované na číslo <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Je dostupné zařízení Bluetooth"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Zařízení žádá o připojení. Podrobnosti zobrazíte klepnutím."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Připojit k zařízení Bluetooth?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"Zařízení <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> žádá o připojení k tomuto telefonu.\n\nK zařízení <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> jste se ještě nikdy nepřipojili."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Nepřipojovat"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Připojit"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Nastavení TARE"</string>
    <string name="tare_on" msgid="2386073225978684535">"Zapnuto"</string>
    <string name="tare_off" msgid="6305694402929756726">"Vypnuto"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Obnovit výchozí nastavení"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Bylo vráceno výchozí nastavení."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Maximální balance při plném nabití"</string>
    <string name="tare_balances" msgid="731881382594747961">"Zůstatky"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Limity spotřeby"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Počáteční limit spotřeby"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Limit minimální spotřeby"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Limit maximální spotřeby"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modifikátory"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Akce (náklady na výrobu)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Akce (základní cena)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Odměny za jednu událost"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Odměny za sekundu trvání události"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maximální počet odměn za den"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Instalace aplikace"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Nejvyšší aktivita"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Oznámení bylo zobrazeno"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Oznámení bylo zobrazeno během 15 minut"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interakce s oznámením"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Interakce s widgetem"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Jiná interakce provedená uživatelem"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Spustit úlohu s maximální prioritou"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Úloha s maximální prioritou je spuštěna"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Spustit úlohu s vysokou prioritou"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Úloha s vysokou prioritou je spuštěna"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Spustit úlohu s výchozí prioritou"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Úloha s výchozí prioritou je spuštěna"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Spustit úlohu s nízkou prioritou"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Úloha s nízkou prioritou je spuštěna"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Úloha s minimální prioritou je spuštěna"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Úloha s minimální prioritou je spuštěna"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Penalta za překročení časového limitu"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Minimální zůstatek při úplném nabití (aplikace s výjimkou)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Minimální zůstatek při úplném nabití (neinteraktivní systémová aplikace)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Minimální zůstatek při úplném nabití (zbývající aplikace)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Minimální zůstatek při úplném nabití (aktualizace aplikací)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Nabíjení"</item>
    <item msgid="658627268149681677">"Zdřímnutí"</item>
    <item msgid="1599558140284643834">"Úsporný režim"</item>
    <item msgid="588427840913221601">"Stav zpracování"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Potvrdit"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Náhled"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Vyberte spořič obrazovky"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Zobrazovat další informace"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Zobrazovat na spořiči obrazovky informace jako čas, počasí atd."</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Zobrazit ovládání domácnosti"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Zobrazovat na spořiči obrazovky tlačítko ovládání domácnosti"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Další nastavení"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Vyberte spořič obrazovky"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Určete, co chcete vídat na obrazovce, když je tablet v doku. Při používání spořiče obrazovky může mít zařízení vyšší spotřebu energie."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Přizpůsobit"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Přizpůsobit <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"K zapnutí podpory plovoucích oken je vyžadován restart."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"K vynucení režimu plochy na sekundárních displejích je vyžadován restart."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Restartovat hned"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Restartovat později"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Prostorový zvuk"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Zvuk z kompatibilních mediálních zařízení bude realističtější"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Sledování hlavy"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Při pohybu hlavou se zvuk mění, aby zněl přirozeněji"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="7277580382321003521">"Synchronizace oprávnění z telefonu"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="8125037984381432059">"Dejte hodinkám stejná oprávnění pro aplikace, jaká jste povolili v telefonu"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Typ zvukového zařízení"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Neznámé"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Reproduktor"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Sluchátka"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Naslouchátko"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Sada handsfree do auta"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Jiné"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Limit rychlosti stahování v síti"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Možnost nakonfigurovat limit rychlosti připojení k síti u příchozích přenosů, který bude platit pro všechny sítě poskytující připojení k internetu."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Konfigurace limitu rychlosti stahování v síti"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Bez omezení"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Deaktivace omezení podřízených procesů"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Deaktivovat omezení využití zdrojů systému podřízenými procesy aplikace"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Vynutit aktivování role Poznámky"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Aktivovat integrace systému psaní poznámek prostřednictvím role Poznámky. Pokud je role Poznámky už aktivována, nic se nestane. Vyžaduje restart."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Vysílání"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Vysílat v aplikaci <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Poslouchejte vysílání v okolí"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Vysílejte mediální obsah do zařízení v okolí nebo poslouchejte vysílání někoho jiného"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Vysílání"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Poslech vysílání"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Najít vysílání"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Opustit vysílání"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Načtení QR kódu"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Zadejte heslo"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Nelze se připojit. Zkuste to znovu."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Nesprávné heslo"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"K vysílání se nepodařilo připojit"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Pokud chcete začít poslouchat, zaměřte QR kód níže"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"QR kód není platný formát"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Převést na eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Přenést eSIM do jiného zařízení"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# aplikace}few{# aplikace}many{# aplikace}other{# aplikací}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Aplikace nainstalované na pozadí"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Výrobce může do zařízení instalovat aplikace na pozadí nebo to může umožnit operátorovi a dalším partnerům.\n\nZde uvedené aplikace nejsou nezbytné k běžnému fungování zařízení. Aplikace, které nechcete, můžete odinstalovat."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Na pozadí nejsou nainstalovány žádné aplikace"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Odinstalovat aplikaci"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Aplikace nainstalované během posledního # měsíce}few{Aplikace nainstalované během posledních # měsíců}many{Aplikace nainstalované během posledního # měsíce}other{Aplikace nainstalované během posledních # měsíců}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Aplikace nainstalované před více než # měsícem}few{Aplikace nainstalované před více než # měsíci}many{Aplikace nainstalované před více než # měsíce}other{Aplikace nainstalované před více než # měsíci}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Poměr stran"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Vyzkoušejte nový poměr stran, ve kterém se bude aplikace zobrazovat, pokud není určena pro rozměr obrazovky vašeho zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Vyzkoušejte nový poměr stran, ve kterém se bude aplikace zobrazovat, pokud není určena pro rozměr obrazovky vašeho zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Některé aplikace nemusí být optimalizované pro určité poměry stran."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Navrhované aplikace"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Změněné aplikace"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Výchozí možnost aplikace"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Celá obrazovka"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Polovina obrazovky"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Poměr stran zařízení"</string>
    <string name="user_aspect_ratio_16_9" msgid="2286644872775170164">"16 : 9"</string>
    <string name="user_aspect_ratio_3_2" msgid="199262962518318932">"3:2"</string>
    <string name="user_aspect_ratio_4_3" msgid="5196232982878982220">"4 : 3"</string>
    <string name="user_aspect_ratio_option_a11y" msgid="1235801996029095219">"<xliff:g id="DENOMINATOR">%2$s</xliff:g>: <xliff:g id="NUMERATOR">%1$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"Když změníte poměr stran, aplikace se restartuje. Můžete přijít o neuložené změny. Některé aplikace nemusí být optimalizované pro určité poměry stran."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Poměr stran (experimentální)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Poměr stran (experiment)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Poměr stran (experimentální funkce)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Experimentální"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Experiment"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Experimentální funkce"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Snímač otisků prstů"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Světelná oznámení"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Informace o světelných oznámeních"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Vypnuto"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Zapnuto / blikání fotoaparátu"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Zapnuto / blikání obrazovky"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Zapnuto / blikání fotoaparátu a obrazovky"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Když dostanete oznámení nebo zazní budík, obrazovka nebo světlo fotoaparátu zablikají"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Zablikat obrazovkou, když dostanete oznámení nebo zazní budík"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Pokud jste citliví na světlo, používejte světelná oznámení opatrně."</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"blikání, světlo, nedoslýchavost, ztráta sluchu"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Náhled"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Blikání fotoaparátu"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Blikání obrazovky"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Barva blikání obrazovky"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Modrá"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Azurová"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Azurová"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Jarní zelená"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Zelená"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Zelenožlutá"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Žlutá"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Oranžová"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Červená"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Růžová"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Purpurová"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Fialová"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Hotovo"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Zrušit"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standardní"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Střední"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Vysoká"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Tuto aplikaci lze otevřít jen v jednom okně"</string>
    <string name="generic_accessibility_service_on" msgid="4466229372357726824">"Zapnuto"</string>
    <string name="generic_accessibility_service_off" msgid="4759859497651675724">"Vypnuto"</string>
    <string name="generic_accessibility_feature_shortcut_off" msgid="4022872394514077907">"Vypnuto"</string>
    <string name="accessibility_shortcut_state_off" msgid="8158137799007601475">"Vypnuto"</string>
    <string name="daltonizer_state_on" msgid="131013270022603983">"Zapnuto"</string>
    <string name="daltonizer_state_off" msgid="1162285688069856179">"Vypnuto"</string>
    <string name="color_inversion_state_on" msgid="1160969033636440368">"Zapnuto"</string>
    <string name="color_inversion_state_off" msgid="6925638668080451724">"Vypnuto"</string>
    <string name="color_inversion_feature_summary" msgid="1199876648549627647">"Světlou obrazovku změní na tmavou a tmavou na světlou"</string>
    <string name="magnification_feature_summary" msgid="641825267460247848">"Obrazovku si můžete rychle přiblížit, aby byl obsah větší"</string>
    <string name="autoclick_disabled" msgid="3213396804955002120">"Vypnuto"</string>
    <string name="show_captions_disabled" msgid="690650956523818755">"Vypnuto"</string>
    <string name="show_captions_enabled" msgid="7089043007924626">"Zapnuto"</string>
    <string name="live_caption_disabled" msgid="3562035026547887366">"Vypnuto"</string>
    <string name="live_caption_enabled" msgid="5269360946200718949">"Zapnuto"</string>
    <string name="about_phone_device_name_warning" msgid="3243226572404472381">"Název vašeho zařízení je viditelný pro nainstalované aplikace. Mohou ho vidět také ostatní uživatelé, když se připojíte k zařízení Bluetooth nebo síti Wi-Fi, případně když vytvoříte hotspot Wi-Fi."</string>
    <string name="grammatical_gender_title" msgid="8584242850477270828">"Mluvnický rod"</string>
    <string name="grammatical_gender_dialog_title" msgid="8754048592099871587">"Vyberte mluvnický rod"</string>
    <!-- no translation found for quarantined_apps_title (5713301345723474936) -->
    <skip />
</resources>
