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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="4676390750360727396">"Ano"</string>
    <string name="no" msgid="6731231425810196216">"Ne"</string>
    <string name="create" msgid="3578857613172647409">"Vytvořit"</string>
    <string name="allow" msgid="3349662621170855910">"Povolit"</string>
    <string name="deny" msgid="6947806159746484865">"Odmítnout"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Neznámé"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="7201398282729229649">
      <item quantity="few">Ještě <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> kroky a bude z vás vývojář.</item>
      <item quantity="many">Ještě <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> kroku a bude z vás vývojář.</item>
      <item quantity="other">Ještě <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> kroků a bude z vás vývojář.</item>
      <item quantity="one">Ještě <xliff:g id="STEP_COUNT_0">%1$d</xliff:g> krok a bude z vás vývojář.</item>
    </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Voilà! Stal se z vás vývojář."</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Není potřeba, již jste vývojář."</string>
    <string name="dev_settings_disabled_warning" msgid="4909448907673974370">"Nejprve prosím aktivujte možnosti pro vývojáře."</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Bezdrátová připojení a sítě"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Systém"</string>
    <string name="radio_info_data_connection_enable" msgid="8656750679353982712">"Povolit datové připojení"</string>
    <string name="radio_info_data_connection_disable" msgid="8541302390883231216">"Zakázat datové připojení"</string>
    <string name="volte_provisioned_switch_string" msgid="7979882929810283786">"Poskytnutí VoLTE"</string>
    <string name="vt_provisioned_switch_string" msgid="7876998291744854759">"Zajištění videohovoru"</string>
    <string name="wfc_provisioned_switch_string" msgid="3985406545172898078">"Zajištění volání přes Wi-Fi"</string>
    <string name="eab_provisioned_switch_string" msgid="3482272907448592975">"Zajištění EAB/přítomnosti"</string>
    <string name="cbrs_data_switch_string" msgid="2811485394350106691">"Data CBRS"</string>
    <string name="dsds_switch_string" msgid="4832797810509029243">"Aktivovat DSDS"</string>
    <string name="dsds_dialog_title" msgid="4031918551366689574">"Restartovat zařízení?"</string>
    <string name="dsds_dialog_message" msgid="8593083316067158412">"Ke změně nastavení je nutné restartovat zařízení."</string>
    <string name="dsds_dialog_confirm" msgid="2853118984344309612">"Restartovat"</string>
    <string name="dsds_dialog_cancel" msgid="654653450305828711">"Zrušit"</string>
    <string name="radio_info_radio_power" msgid="7187666084867419643">"Výkon mobilního přijímače"</string>
    <string name="radioInfo_menu_viewADN" msgid="7069468158519465139">"Zobrazit adresář SIM karty"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Zobrazit povolená telefonní čísla"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Zobrazit čísla volání služeb"</string>
    <string name="radioInfo_menu_getIMS" msgid="185171476413967831">"Stav služby IMS"</string>
    <string name="radio_info_ims_reg_status_title" msgid="16971785902696970">"Stav IMS"</string>
    <string name="radio_info_ims_reg_status_registered" msgid="5614116179751126247">"Registrováno"</string>
    <string name="radio_info_ims_reg_status_not_registered" msgid="4438054067642750717">"Neregistrováno"</string>
    <string name="radio_info_ims_feature_status_available" msgid="3687807290327566879">"Dostupné"</string>
    <string name="radio_info_ims_feature_status_unavailable" msgid="4606182208970114368">"Nedostupné"</string>
    <string name="radio_info_ims_reg_status" msgid="7534612158445529715">"Registrace IMS: <xliff:g id="STATUS">%1$s</xliff:g>\nVolání přes LTE: <xliff:g id="AVAILABILITY_0">%2$s</xliff:g>\nVolání přes Wi-Fi: <xliff:g id="AVAILABILITY_1">%3$s</xliff:g>\nVideohovory: <xliff:g id="AVAILABILITY_2">%4$s</xliff:g>\nRozhraní UT: <xliff:g id="AVAILABILITY_3">%5$s</xliff:g>"</string>
    <string name="radioInfo_service_in" msgid="1697703164394784618">"V provozu"</string>
    <string name="radioInfo_service_out" msgid="7999094221728929681">"Mimo provoz"</string>
    <string name="radioInfo_service_emergency" msgid="6274434235469661525">"Pouze tísňová volání"</string>
    <string name="radioInfo_service_off" msgid="7536423790014501173">"Bezdrátový modul je vypnut"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="4849214885629672819">"Bez roamingu"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Nečinný"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Vyzvánění"</string>
    <string name="radioInfo_phone_offhook" msgid="5873835692449118954">"Probíhá hovor"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Odpojeno"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Připojování"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Připojeno"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Pozastaveno"</string>
    <string name="radioInfo_unknown" msgid="1476509178755955088">"Neznámé"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"pakety"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"B"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Odpojit úložiště USB"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Odpojit kartu SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Smazat úložiště USB"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Smazat kartu SD"</string>
    <string name="preview_pager_content_description" msgid="8926235999291761243">"Náhled"</string>
    <string name="preview_page_indicator_content_description" msgid="4821343428913401264">"Náhled, stránka <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> z <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="font_size_summary" msgid="1690992332887488183">"Umožňuje zvětšit nebo zmenšit text na obrazovce."</string>
    <string name="font_size_make_smaller_desc" msgid="7919995133365371569">"Zmenšit"</string>
    <string name="font_size_make_larger_desc" msgid="4316986572233686061">"Zvětšit"</string>
    <!-- no translation found for font_size_preview_text (4818424565068376732) -->
    <skip />
    <string name="font_size_preview_text_headline" msgid="7955317408475392247">"Ukázkový text"</string>
    <string name="font_size_preview_text_title" msgid="1310536233106975546">"Čaroděj ze země Oz"</string>
    <string name="font_size_preview_text_subtitle" msgid="4231671528173110093">"Kapitola 11: Smaragdové město v zemi Oz"</string>
    <string name="font_size_preview_text_body" msgid="2846183528684496723">"I přestože měli oči chráněné zelenými brýlemi, Dorotka a její přátelé byli oslněni krásou celého města. Ulice byly lemovány nádhernými domy ze zeleného mramoru posetého blyštivými smaragdy. Chodníky byly dlážděny stejným druhem zeleného mramoru a jednotlivé dlaždice od sebe dělily řady úzce sázených smaragdů, které se leskly ve slunečním svitu. Okenní tabule byly ze zeleného skla, dokonce i obloha nad městem měla zelený nádech i sluneční paprsky byly zelené. \n\nKolem procházelo mnoho lidí – muži, ženy i děti. Všichni byli zelení a nosili zelené oblečení. Zraky všech se upíraly na Dorotku a její neobvykle různorodé společníky. Když děti zahlédly i Lva, utíkaly se schovat za své maminky. Nikdo se neodvážil na skupinku promluvit. V ulici bylo mnoho obchodů a Dorotka si všimla, že také v nich je všechno zelené. Bonbony, popcorn, boty, klobouky, oblečení všech druhů.Na jednom místě prodávali zelenou limonádu, a když ji děti kupovaly, platily za ni zelenými mincemi. \n\nZdálo se, že ve městě nejsou koně ani jakákoli zvířata. Lidé k převážení věcí používali zelené vozíky, které tlačili před sebou. Všichni vypadali, že jsou spokojeni a daří se jim."</string>
    <string name="font_size_save" msgid="3450855718056759095">"OK"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Úložiště USB"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"Karta SD"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"Viditelné pro všechna okolní zařízení Bluetooth (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Viditelné pro všechny okolní zařízení Bluetooth"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Neviditelné pro ostatní zařízení Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Viditelné pouze pro spárovaná zařízení"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Časový limit viditelnosti"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Uzamknout hlasové vytáčení"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Zabránit použití vytáčení Bluetooth při uzamčené obrazovce"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Zařízení Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Název zařízení"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Nastavení zařízení"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Nastavení profilu"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Název není nastaven, použit název účtu"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Vyhledat zařízení"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Přejmenovat toto zařízení"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Přejmenovat"</string>
    <string name="bluetooth_disconnect_title" msgid="7830252930348734303">"Odpojit zařízení?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="8208712728668714199">"Telefon se odpojí od zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="tablet" msgid="6611038575213485336">"Tablet se odpojí od zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="device" msgid="3995834526315103965">"Zařízení se odpojí od zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="3308586619539119106">"Odpojit"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="603521233563983689">"Nemáte oprávnění měnit nastavení Bluetooth."</string>
    <string name="bluetooth_pairing_pref_title" msgid="7429413067477968637">"Spárovat nové zařízení"</string>
    <string name="bluetooth_is_visible_message" msgid="6222396240776971862">"Při zapnutém připojení Bluetooth je zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> viditelné pro zařízení v okolí."</string>
    <string name="bluetooth_footer_mac_message" product="default" msgid="1109366350000220283">"Adresa Bluetooth telefonu: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="tablet" msgid="6807634484499166486">"Adresa Bluetooth tabletu: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="device" msgid="8413944740341742061">"Adresa Bluetooth zařízení: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_is_disconnect_question" msgid="5334933802445256306">"Odpojit zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Vysílání"</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Nepojmenované zařízení Bluetooth"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Hledání"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"V okolí nejsou žádná zařízení Bluetooth."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Požadavek na párování zařízení Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Požadavek na párování"</string>
    <string name="bluetooth_notif_message" msgid="5057417127600942904">"Klepnutím spárujete se zařízením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="3144149432555230410">"Přijaté soubory"</string>
    <string name="bluetooth_show_files_received_via_bluetooth" msgid="5445105773989432594">"Soubory přijaté přes Bluetooth"</string>
    <string name="device_picker" msgid="4978696506172252813">"Vybrat zařízení Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="3387222809404177525">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnout Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="5890386255790160573">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> chce vypnout Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="1644353686104482763">"Aplikace chce zapnout Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="9218830122674868548">"Aplikace chce vypnout Bluetooth"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="4791779658660357386">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> požaduje zviditelnění tabletu pro ostatní zařízení Bluetooth na <xliff:g id="TIMEOUT">%2$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="1308225382575535366">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> požaduje zviditelnění telefonu pro ostatní zařízení Bluetooth na <xliff:g id="TIMEOUT">%2$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery_no_name" product="tablet" msgid="225715443477752935">"Aplikace požaduje zviditelnění tabletu pro ostatní zařízení Bluetooth na <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery_no_name" product="default" msgid="4949152735544109994">"Aplikace požaduje zviditelnění telefonu pro ostatní zařízení Bluetooth na <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8528329166577187961">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> požaduje zviditelnění tabletu pro ostatní zařízení Bluetooth. Svoji volbu můžete později změnit v nastavení Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="4398738575307583138">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> požaduje zviditelnění telefonu pro ostatní zařízení Bluetooth. Svoji volbu můžete později změnit v nastavení Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet" msgid="1702590641426207062">"Aplikace chce tablet zviditelnit pro ostatní zařízení Bluetooth. Svoji volbu můžete později změnit v nastavení Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="default" msgid="8549952177383992238">"Aplikace chce telefon zviditelnit pro ostatní zařízení Bluetooth. Svoji volbu můžete později změnit v nastavení Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="1141843490422565755">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnout Bluetooth a na <xliff:g id="TIMEOUT">%2$d</xliff:g> s tablet zviditelnit pro ostatní zařízení."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="5195836980079191473">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnout Bluetooth a na <xliff:g id="TIMEOUT">%2$d</xliff:g> s telefon zviditelnit pro ostatní zařízení."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="tablet" msgid="7009338445281693765">"Aplikace chce zapnout Bluetooth a na <xliff:g id="TIMEOUT">%1$d</xliff:g> s tablet zviditelnit pro ostatní zařízení."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="default" msgid="8386904242279878734">"Aplikace chce zapnout Bluetooth a na <xliff:g id="TIMEOUT">%1$d</xliff:g> s telefon zviditelnit pro ostatní zařízení."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="2279471426575892686">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnout Bluetooth a zviditelnit tablet pro ostatní zařízení. Svoji volbu můžete později změnit v nastavení Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6961969825475461450">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnout Bluetooth a zviditelnit telefon pro ostatní zařízení. Svoji volbu můžete později změnit v nastavení Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="tablet" msgid="692477613671555006">"Aplikace chce zapnout Bluetooth a zviditelnit tablet pro ostatní zařízení. Svoji volbu můžete později změnit v nastavení Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="default" msgid="6374480121751597648">"Aplikace chce zapnout Bluetooth a zviditelnit telefon pro ostatní zařízení. Svoji volbu můžete později změnit v nastavení Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Zapínání Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Vypínání rozhraní Bluetooth…"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Požadavek na připojení zařízení Bluetooth"</string>
    <string name="bluetooth_connection_notif_message" msgid="3603316575471431846">"Klepnutím se připojíte k zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Chcete se připojit k zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Požadavek na přístup k telefonnímu seznamu"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="8930347091018455505">"Zařízení <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> chce získat přístup k vašim kontaktům a historii volání. Chcete zařízení <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> přístup udělit?"</string>
    <string name="bluetooth_remember_choice" msgid="6919682671787049800">"Příště se neptat"</string>
    <string name="bluetooth_pb_remember_choice" msgid="3622898084442402071">"Příště se neptat"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Požadavek na přístup ke zprávám"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"Zařízení %1$s žádá o přístup k vašim zprávám. Povolit přístup zařízení %2$s?"</string>
    <string name="bluetooth_sap_request" msgid="2669762224045354417">"Žádost o přístup k SIM kartě"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="4414253873553608690">"Zařízení <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> žádá o přístup k SIM kartě. Po dobu přístupu zařízení k SIM kartě bude datové připojení ve vašem zařízení vypnuto. Chcete zařízení <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g> povolit přístup?"</string>
    <string name="bluetooth_device_name_summary" msgid="522235742194965734">"Viditelné pro ostatní zařízení jako „<xliff:g id="DEVICE_NAME">^1</xliff:g>“"</string>
    <string name="bluetooth_off_footer" msgid="8406865700572772936">"Chcete-li se připojit k ostatním zařízením, zapněte Bluetooth."</string>
    <string name="bluetooth_paired_device_title" msgid="8638994696317952019">"Vaše zařízení"</string>
    <string name="bluetooth_pairing_page_title" msgid="7712127387361962608">"Spárovat nové zařízení"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3520035819421024105">"Povolte tabletu komunikovat se zařízeními Bluetooth v okolí"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2205100629387332862">"Povolte zařízení komunikovat se zařízeními Bluetooth v okolí"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="782032074675157079">"Povolte telefonu komunikovat se zařízeními Bluetooth v okolí"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="4936610906348223810">"Zakázat hardwarové snížení zátěže Bluetooth (A2DP)"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title" msgid="4340101417209145308">"Restartovat zařízení?"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message" msgid="8827019472003234568">"Ke změně nastavení je nutné restartovat zařízení."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="2053793518537051975">"Restartovat"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="2382443064737856652">"Zrušit"</string>
    <string name="connected_device_available_media_title" msgid="2560067541413280645">"Dostupná mediální zařízení"</string>
    <string name="connected_device_available_call_title" msgid="697154660967595684">"Dostupná telefonní zařízení"</string>
    <string name="connected_device_connected_title" msgid="5871712271201945606">"Momentálně připojeno"</string>
    <string name="connected_device_saved_title" msgid="688364359746674536">"Uložená zařízení"</string>
    <string name="connected_device_add_device_summary" msgid="4041865900298680338">"Zapne se Bluetooth za účelem spárování"</string>
    <string name="connected_device_connections_title" msgid="5988939345181466770">"Předvolby připojení"</string>
    <string name="connected_device_previously_connected_title" msgid="491765792822244604">"Dříve připojená zařízení"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="6196066429488377795">"Dříve připojeno"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="5683648191381637533">"Bluetooth je zapnuto"</string>
    <string name="previous_connected_see_all" msgid="3626779872898778415">"Zobrazit vše"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Datum a čas"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Vybrat časové pásmo"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Odeslat <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Spustit činnost <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Účet:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Proxy"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Vymazat"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Port proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Nepoužívat proxy server pro"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Obnovit výchozí nastavení"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Hotovo"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Název hostitele proxy serveru"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Upozornění"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="6865850167802455230">"Zadaný název hostitele není platný."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="678527645450894773">"Seznam vyloučení, který jste vytvořili, má nesprávný formát. Zadejte seznam názvů domén k vyloučení a jednotlivé názvy oddělte čárkami."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Vyplňte pole portu."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Pokud je pole hostitel prázdné, musí být prázdné i pole port."</string>
    <string name="proxy_error_invalid_port" msgid="5988270202074492710">"Zadaný port není platný."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Proxy server protokolu HTTP může používat prohlížeč, ale nesmí jej používat další aplikace."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"Adresa URL PAC: "</string>
    <string name="radio_info_subid" msgid="204582608052503412">"Stávající subId:"</string>
    <string name="radio_info_dds" msgid="5471937791273237508">"SubId výchozí datové SIM karty:"</string>
    <string name="radio_info_dl_kbps" msgid="6894556071523815984">"Rychlost stahování (kB/s):"</string>
    <string name="radio_info_ul_kbps" msgid="946464073571185678">"Rychlost nahrávání (kB/s):"</string>
    <string name="radio_info_signal_location_label" msgid="3242990404410530456">"Informace o poloze mobilní sítě (podpora ukončena):"</string>
    <string name="radio_info_phy_chan_config" msgid="7133247058801474028">"Konfigurace fyzického kanálu LTE:"</string>
    <string name="radio_info_cell_info_refresh_rate" msgid="7062777594049622128">"Interval obnovení informací o mobilní síti:"</string>
    <string name="radio_info_cellinfo_label" msgid="6213223844927623098">"Všechny údaje o měření mobilní sítě:"</string>
    <string name="radio_info_gprs_service_label" msgid="4209624131644060517">"Datová služba:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Roaming:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="2743797189722106231">"Přesměrování hovoru:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3587319503902576102">"Počet obnovení protokolu PPP od spuštění:"</string>
    <string name="radio_info_current_network_label" msgid="9151285540639134945">"Aktuální síť:"</string>
    <string name="radio_info_ppp_received_label" msgid="363579470428151850">"Přijatá data:"</string>
    <string name="radio_info_gsm_service_label" msgid="1370863866816125489">"Hlasová služba:"</string>
    <string name="radio_info_signal_strength_label" msgid="5155734002519307416">"Síla signálu:"</string>
    <string name="radio_info_call_status_label" msgid="2611065018172747413">"Stav hlasového hovoru:"</string>
    <string name="radio_info_ppp_sent_label" msgid="7748668735880404586">"Odeslaná data:"</string>
    <string name="radio_info_message_waiting_label" msgid="1037302619943328273">"Čekající zpráva:"</string>
    <string name="radio_info_phone_number_label" msgid="7942153178953255231">"Telefonní číslo:"</string>
    <string name="radio_info_band_mode_label" msgid="8730871744887454509">"Zvolit pásmo bezdrátového modulu"</string>
    <string name="radio_info_voice_network_type_label" msgid="1443496502370667071">"Typ hlasové sítě:"</string>
    <string name="radio_info_data_network_type_label" msgid="7094323145105149312">"Typ datové sítě:"</string>
    <string name="phone_index_label" msgid="1934407597576454430">"Vybrat telefonní seznam"</string>
    <string name="radio_info_set_perferred_label" msgid="3511830813500105512">"Nastavit upřednostňovaný typ sítě:"</string>
    <string name="radio_info_ping_hostname_v4" msgid="7045103377818314709">"Ping názvu hostitele (www.google.com) IPv4:"</string>
    <string name="radio_info_ping_hostname_v6" msgid="1130906124160553954">"Ping názvu hostitele (www.google.com) IPv6:"</string>
    <string name="radio_info_http_client_test" msgid="2382286093023138339">"Test klienta HTTP:"</string>
    <string name="ping_test_label" msgid="579228584343892613">"Spustit test Ping"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Aktualizovat"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Aktualizovat"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="6625185764803245075">"Přepnout kontrolu DNS"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Informace a nastavení specifické pro výrobce OEM"</string>
    <string name="band_mode_title" msgid="4071411679019296568">"Nastavit režim pásma bezdrátového modulu"</string>
    <string name="band_mode_loading" msgid="3555063585133586152">"Načítání seznamu pásem…"</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Nastavit"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Neúspěšné"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Pásmo nastaveno."</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Změny se projeví při příštím připojení kabelu USB."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Povolit velkokapacitní úložiště USB"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Celková paměť (bajty):"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"Úložiště USB není připojeno."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Karta SD není k dispozici."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Dostupná paměť (bajty):"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"Úlož. USB užito jako velkokap."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"Karta SD je využívána jako velkokapacitní paměťové zařízení."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="5128923500235719226">"Úlož. USB lze bezp. odebrat."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="666233604712540408">"Nyní můžete kartu SD bezpečně odebrat."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"Úlož. USB odebráno za provozu."</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"Karta SD byla odstraněna za provozu."</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Obsazená paměť (bajty):"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Hledání médií v úložišti USB…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Vyhledávání mediálních souborů na kartě SD..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"Úlož. USB připoj. jen ke čtení"</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"Karta SD je připojena pouze pro čtení."</string>
    <string name="skip_label" msgid="47510779345218297">"Přeskočit"</string>
    <string name="next_label" msgid="4693520878012668114">"Další"</string>
    <string name="language_picker_title" msgid="3596315202551687690">"Jazyky"</string>
    <string name="locale_remove_menu" msgid="7651301406723638854">"Odstranit"</string>
    <string name="add_a_language" msgid="2330538812283783022">"Přidat jazyk"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="4276642359346122396">
      <item quantity="few">Odstranit vybrané jazyky?</item>
      <item quantity="many">Odstranit vybrané jazyky?</item>
      <item quantity="other">Odstranit vybrané jazyky?</item>
      <item quantity="one">Odstranit vybraný jazyk?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="1361354927342876114">"Text se bude zobrazovat v jiném jazyce."</string>
    <string name="dlg_remove_locales_error_title" msgid="2653242337224911425">"Nelze odstranit všechny jazyky"</string>
    <string name="dlg_remove_locales_error_message" msgid="6697381512654262821">"Ponechte alespoň jeden preferovaný jazyk"</string>
    <string name="locale_not_translated" msgid="516862628177166755">"V některých aplikacích nemusí být k dispozici"</string>
    <string name="action_drag_label_move_up" msgid="9052210023727612540">"Přesunout nahoru"</string>
    <string name="action_drag_label_move_down" msgid="7448713844582912157">"Přesunout dolů"</string>
    <string name="action_drag_label_move_top" msgid="557081389352288310">"Přesunout na začátek"</string>
    <string name="action_drag_label_move_bottom" msgid="2468642142414126482">"Přesunout na konec"</string>
    <string name="action_drag_label_remove" msgid="2861038147166966206">"Odstranit jazyk"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Vybrat aktivitu"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Info o zařízení"</string>
    <string name="display_label" msgid="8074070940506840792">"Displej"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Informace o tabletu"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informace o telefonu"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Úložiště USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"Karta SD"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Nastavení proxy serveru"</string>
    <string name="cancel" msgid="6859253417269739139">"Zrušit"</string>
    <string name="okay" msgid="1997666393121016642">"OK"</string>
    <string name="forget" msgid="1400428660472591263">"Zapomenout"</string>
    <string name="save" msgid="879993180139353333">"Uložit"</string>
    <string name="done" msgid="6942539184162713160">"Hotovo"</string>
    <string name="apply" msgid="1577045208487259229">"Použít"</string>
    <string name="share" msgid="6791534619806355910">"Sdílet"</string>
    <string name="add" msgid="3709942705501136412">"Přidat"</string>
    <string name="settings_label" msgid="1626402585530130914">"Nastavení"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Nastavení"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Zástupce nastavení"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Režim Letadlo"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Bezdrátová připojení a sítě"</string>
    <string name="radio_controls_summary" msgid="1838624369870907268">"Spravovat Wi-Fi, Bluetooth, režim Letadlo, mobilní sítě a sítě VPN"</string>
    <string name="cellular_data_title" msgid="6835451574385496662">"Mobilní data"</string>
    <string name="calls_title" msgid="1262096900483238572">"Povolit hovory"</string>
    <string name="sms_messages_title" msgid="1778636286080572535">"Zprávy SMS"</string>
    <string name="cellular_data_summary" msgid="4660351864416939504">"Povolit využití dat přes mobilní síť"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Povolit data při roamingu"</string>
    <string name="roaming" msgid="2619521775007402005">"Roaming"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Používat datové služby při roamingu"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Používat datové služby při roamingu"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Připojení datových služeb bylo přerušeno, protože jste opustili domovskou síť a máte vypnutý datový roaming."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Zapnout"</string>
    <string name="roaming_warning" msgid="4275443317524544705">"Mohou vám být účtovány vysoké poplatky."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Pokud aktivujete datový roaming, mohou vám být za roaming účtovány nemalé poplatky.\n\nToto nastavení ovlivní všechny uživatele tohoto tabletu."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Pokud aktivujete datový roaming, mohou vám být za roaming účtovány nemalé poplatky.\n\nToto nastavení ovlivní všechny uživatele tohoto telefonu."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Povolit datový roaming?"</string>
    <string name="networks" msgid="6333316876545927039">"Výběr operátora"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Vybrat síťového operátora"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Datum a čas"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Nastavit datum a čas"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Umožňuje nastavit datum, čas, časové pásmo a formát"</string>
    <string name="date_time_auto" msgid="4290527098376721491">"Používat čas ze sítě"</string>
    <string name="zone_auto_title" msgid="3217703906014135437">"Používat časové pásmo ze sítě"</string>
    <string name="date_time_24hour_auto" msgid="6276269188890332084">"Použít zdejší výchozí formát"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"24hodinový formát"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Používat 24hodinový formát"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Čas"</string>
    <string name="time_format_category_title" msgid="736190761036057769">"Formát času"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Časové pásmo"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Časové pásmo"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Datum"</string>
    <string name="date_time_search_region" msgid="2478334699004021972">"Vyhledat oblast"</string>
    <string name="date_time_select_region" msgid="5434001881313168586">"Region"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="6084375085203448645">"Vyberte časový rozdíl"</string>
    <string name="zone_change_to_from_dst" msgid="118656001224045590">"<xliff:g id="TIME_TYPE">%1$s</xliff:g> začíná <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="1359698475641349336">"<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="164876167707284017">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer" msgid="4192803402331390389">"Používá <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="DST_TIME_TYPE">%2$s</xliff:g> začíná <xliff:g id="TRANSITION_DATE">%3$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8652423870143056964">"Používá <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Nepoužívá letní čas."</string>
    <string name="zone_time_type_dst" msgid="8850494578766845276">"Letní čas"</string>
    <string name="zone_time_type_standard" msgid="3462424485380376522">"Standardní čas"</string>
    <string name="zone_menu_by_region" msgid="8370437123807764346">"Vybrat podle oblasti"</string>
    <string name="zone_menu_by_offset" msgid="7161573994228041794">"Vybrat podle posunu od UTC"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Datum"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Čas"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Automaticky zamknout za"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po přechodu do spánku"</string>
    <string name="lock_immediately_summary_with_exception" msgid="9119632173886172690">"Okamžitě po režimu spánku, pokud odemknutí není udržováno pomocí agenta <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="5579064842797188409">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po přechodu do spánku, pokud odemknutí není udržováno funkcí <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Zobrazovat vlastníka na zamčené obrazovce"</string>
    <string name="owner_info_settings_title" msgid="5530285568897386122">"Zpráva na zamčené obrazovce"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Aktivovat widgety"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="6392489775303464905">"Zakázáno administrátorem"</string>
    <string name="lockdown_settings_title" msgid="7393790212603280213">"Zobrazit možnost uzamčení"</string>
    <string name="lockdown_settings_summary" msgid="429230431748285997">"Zobrazí vypínač, který vypíná funkci Smart Lock, odemykání otiskem prstu a oznámení na obrazovce uzamčení."</string>
    <string name="trust_agents_extend_unlock_title" msgid="2796555263565097031">"Agenti důvěry jen prodlužují odemčení"</string>
    <string name="trust_agents_extend_unlock_summary" msgid="3976344969220255010">"Bude-li tato možnost aktivována, agenti důvěry ponechají vaše zařízení odemčená delší dobu, ale uzamčené zařízení už nebudou moci odemknout."</string>
    <string name="trust_lost_locks_screen_title" msgid="2992742466966021682">"Zamknout obrazovku při ztrátě důvěry"</string>
    <string name="trust_lost_locks_screen_summary" msgid="693784434582021206">"Když bude možnost aktivována a poslední agent důvěry přestane být důvěryhodný, zařízení se zamkne."</string>
    <string name="owner_info_settings_summary" msgid="7472393443779227052">"Žádná"</string>
    <string name="owner_info_settings_status" msgid="120407527726476378">"<xliff:g id="COUNT_0">%1$d</xliff:g> / <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="7591869574491036360">"Např. Tomův Android."</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Info o uživateli"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Zobrazit informace o profilu na zamčené obrazovce"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Informace o profilu"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Účty"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Poloha"</string>
    <string name="location_settings_master_switch_title" msgid="3560242980335542411">"Používat polohu"</string>
    <string name="location_settings_summary_location_off" msgid="794370259612167176">"Vypnuto"</string>
    <plurals name="location_settings_summary_location_on" formatted="false" msgid="5222949914335428617">
      <item quantity="few">Zapnuto – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikace mají přístup k poloze</item>
      <item quantity="many">Zapnuto – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikace má přístup k poloze</item>
      <item quantity="other">Zapnuto – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikací má přístup k poloze</item>
      <item quantity="one">Zapnuto – <xliff:g id="COUNT_0">%1$d</xliff:g> aplikace má přístup k poloze</item>
    </plurals>
    <string name="location_settings_loading_app_permission_stats" msgid="8523775367089431611">"Načítání…"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Účty"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Zabezpečení"</string>
    <string name="encryption_and_credential_settings_title" msgid="6514904533438791561">"Šifrování a pověření"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="8721883002237981248">"Telefon je zašifrován"</string>
    <string name="decryption_settings_summary" product="default" msgid="5671817824042639849">"Telefon není šifrován"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="7200428573872395685">"Zařízení je zašifrováno"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="5794135636155570977">"Zařízení není šifrováno"</string>
    <string name="lockscreen_settings_title" msgid="1099738951060387656">"Zobrazení na obrazovce uzamčení"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="278055252361575926">"Co zobrazit"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Moje poloha, odemknutí obrazovky, zámek SIM, zámek úložiště pověření"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Nastavení funkce Moje poloha, odemknutí obrazovky a zamknutí úložiště pověření"</string>
    <string name="security_passwords_title" msgid="2881269890053568809">"Ochrana soukromí"</string>
    <string name="disabled_by_administrator_summary" msgid="1601828700318996341">"Zakázáno administrátorem"</string>
    <string name="security_status_title" msgid="5848766673665944640">"Stav zabezpečení"</string>
    <string name="security_dashboard_summary_face" msgid="268234254306703218">"Zámek obrazovky, odemknutí obličejem"</string>
    <string name="security_dashboard_summary" msgid="6757421634477554939">"Zámek obrazovky, otisky prstů"</string>
    <string name="security_dashboard_summary_no_fingerprint" msgid="8129641548372335540">"Zámek obrazovky"</string>
    <string name="security_settings_face_preference_summary" msgid="1290187225482642821">"Obličej přidán"</string>
    <string name="security_settings_face_preference_summary_none" msgid="5460349732790152186">"Klepnutím nastavíte ověřování obličejem"</string>
    <string name="security_settings_face_preference_title" msgid="7074548721778680481">"Ověřování obličejem"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="7784083491315229721">"Použít nastavení přístupnosti"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="4455532390587307262"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7075186169796301461"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="4277182322482408514">"Zrušit"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="2694505011712885439">"Odemykání pomocí obličeje"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="8180330567034286589">"Ověření pomocí obličeje"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="6150611993438981458">"Odemykejte telefon, autorizujte nákupy a přihlašujte se do aplikací."</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="6393270235632444857">"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="5704661081718707858">"Odemykejte telefon, autorizujte nákupy a přihlašujte se do aplikací."</string>
    <string name="security_settings_face_enroll_introduction_footer_message" msgid="6129862379306304035"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4019853239039918762">"Umístěte obličej do středu kruhu"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="1933553314312349529">"Později"</string>
    <string name="face_add_max" msgid="4408683751143942949">"Maximální počet obličejů, které lze přidat: <xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="face_intro_error_max" msgid="160022811747660581">"Přidali jste maximální počet obličejů"</string>
    <string name="face_intro_error_unknown" msgid="6367721696446677261">"Další obličeje přidat nelze"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2869110702072655323">"Registrace nebyla dokončena"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="2980238861223265089">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="1701191960569185087">"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="3825066262969499407">"Registrace obličeje nefungovala."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="8268014305067971249">"Vše je nastaveno."</string>
    <string name="security_settings_face_enroll_done" msgid="6670735678797960484">"Hotovo"</string>
    <string name="security_settings_face_settings_use_face_category" msgid="4102604281840004724">"Používat obličej k"</string>
    <string name="security_settings_face_settings_use_face_unlock_phone" msgid="5275635645351823301">"Odemykání zařízení"</string>
    <string name="security_settings_face_settings_use_face_for_apps" msgid="5751549943998662469">"Přihlašování do aplikací a platby"</string>
    <string name="security_settings_face_settings_require_attention" msgid="1638445716306615123">"Mějte otevřené oči"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="5749808567341263288">"Při ověřování pomocí obličeje musíte mít otevřené oči"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="2559602923985027572">"Vždy vyžadovat potvrzení"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="2002651109571928756">"Při ověřování v aplikacích vždy vyžadovat potvrzení"</string>
    <string name="security_settings_face_settings_remove_face_data" msgid="3477772641643318370">"Odstranit obličej"</string>
    <string name="security_settings_face_settings_footer" msgid="8056977398747222768">"Pomocí obličeje můžete odemykat zařízení a používat aplikace. "<annotation id="url">"Další informace"</annotation></string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="4829278778459836075">"Smazat data o obličeji?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="2609671025686003946">"Data zaznamenaná pomocí funkce odemknutí obličejem budou trvale a bezpečně smazána. Po odstranění budete z účelem odemknutí telefonu, přihlášení do aplikace nebo potvrzení platby muset zadat PIN, gesto nebo heslo."</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2488725232406204350">"Otisk prstu"</string>
    <string name="fingerprint_manage_category_title" msgid="8293801041700001681">"Správa otisků prstů"</string>
    <string name="fingerprint_usage_category_title" msgid="8438526918999536619">"K čemu otisk používat"</string>
    <string name="fingerprint_add_title" msgid="1926752654454033904">"Přidat otisk prstu"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5078060939636911795">"zámek obrazovky"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="624961700033979880">
      <item quantity="few">Nastavení <xliff:g id="COUNT_1">%1$d</xliff:g> otisků prstu</item>
      <item quantity="many">Nastavení <xliff:g id="COUNT_1">%1$d</xliff:g> otisku prstu</item>
      <item quantity="other">Nastavení <xliff:g id="COUNT_1">%1$d</xliff:g> otisků prstu</item>
      <item quantity="one">Nastavení <xliff:g id="COUNT_0">%1$d</xliff:g> otisku prstu</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1507739327565151923"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="3201556857492526098">"Odemknutí otiskem prstu"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="7066417934622827305">"Použití otisku prstu"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="3508870672887336095">"Odemykejte telefon, autorizujte nákupy a přihlašujte se do aplikací pouhým klepnutím na senzor otisků prstů. Dobře zvažte, čí otisky do zařízení přidáte. Uvedené akce bude možné provádět pomocí každého z přidaných otisků.\n\nPoznámka: Otisk prstu může být méně bezpečný než silné gesto nebo PIN."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="1550756694054944874">"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_message_setup" msgid="6817326798834882531">"Odemykejte telefon a schvalujte nákupy otiskem prstu.\n\nPoznámka: Otisk prstu může být méně bezpečný než silné gesto nebo PIN."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="3199351118385606526">"Zrušit"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="7472492858148162530">"Pokračovat"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup" msgid="5021369420474432665">"Přeskočit"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup" msgid="1961957425135180242">"Další"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="362050541117362034">"Přeskočit zadání otisku prstu?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="958990414356204763">"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="lock_screen_intro_skip_title" msgid="4988210105913705679">"Přeskočit zámek obrazovky?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1581834104051243425">"Nebudou zapnuty funkce ochrany zařízení. V případě ztráty, odcizení nebo resetování tabletu nebudete moci ostatním zabránit v jeho používání."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="4629503416877189572">"Nebudou zapnuty funkce ochrany zařízení. V případě ztráty, odcizení nebo resetování zařízení nebudete moci ostatním zabránit v jeho používání."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="2423428240245737909">"Nebudou zapnuty funkce ochrany zařízení. V případě ztráty, odcizení nebo resetování telefonu nebudete moci ostatním zabránit v jeho používání."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="5219287483885558525">"Nebudou zapnuty funkce ochrany zařízení. Pokud tablet ztratíte nebo vám jej někdo ukradne, nebudete lidem moci zabránit v jeho používání."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="1466238255429527112">"Nebudou zapnuty funkce ochrany zařízení. Pokud zařízení ztratíte nebo vám jej někdo ukradne, nebudete lidem moci zabránit v jeho používání."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="3008526710555416125">"Nebudou zapnuty funkce ochrany zařízení. Pokud telefon ztratíte nebo vám jej někdo ukradne, nebudete lidem moci zabránit v jeho používání."</string>
    <string name="skip_anyway_button_label" msgid="2323522873558834513">"Přeskočit"</string>
    <string name="go_back_button_label" msgid="4745265266186209467">"Zpět"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="7478349557867790778">"Přeskočit"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="4525833484240246349">"Zrušit"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="3051496861358227199">"Dotkněte se senzoru"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="8793966374365960368">"Je na zadní straně telefonu. Použijte ukazováček."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="2058830032070449160">"Ilustrace se zařízením a polohou senzoru otisků prstů"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7086763077909041106">"Jméno"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4150384963879569750">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="4114615413240707936">"Smazat"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="2068961812439460133">"Dotkněte se senzoru"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="3909929328942564524">"Položte prst na senzor. Zvedněte ho, až zařízení zavibruje."</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="2819679722403209778">"Zvedněte prst a dotkněte se znovu"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="6158989350522518586">"Opakovaně prst zvedněte, aby se zaznamenaly různé části otisku"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="7567276170287972230">"Otisk byl přidán"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="8970048776120548976">"Když je zobrazena tato ikona, můžete se identifikovat nebo schválit nákup otiskem prstu"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3710211704052369752">"Později"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="6808422329107426923">"Přeskočit nastavení otisku prstu?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="274849306857859783">"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="fingerprint_lock_screen_setup_skip_dialog_text" product="tablet" msgid="5925427033028514518">"Ochraňte svůj tablet pomocí zámku obrazovky, aby ho v případě ztráty či odcizení nemohl použít nikdo cizí. Zámek obrazovky budete také potřebovat, pokud si budete chtít nastavit otisk prstu. Klepněte na Zrušit a poté si nastavte PIN nebo zvolte jiný typ zámku obrazovky."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="device" msgid="2524729541954689407">"Ochraňte své zařízení pomocí zámku obrazovky, aby ho v případě ztráty či odcizení nemohl použít nikdo cizí. Zámek obrazovky budete také potřebovat, pokud si budete chtít nastavit otisk prstu. Klepněte na Zrušit a poté si nastavte PIN nebo zvolte jiný typ zámku obrazovky."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="default" msgid="2941592649076449189">"Ochraňte svůj telefon pomocí zámku obrazovky, aby ho v případě ztráty či odcizení nemohl použít nikdo cizí. Zámek obrazovky budete také potřebovat, pokud si budete chtít nastavit otisk prstu. Klepněte na Zrušit a poté si nastavte PIN nebo zvolte jiný typ zámku obrazovky."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="tablet" msgid="2062547634035791832">"Ochraňte svůj tablet pomocí zámku obrazovky, aby ho v případě ztráty či odcizení nemohl použít nikdo cizí. Zámek obrazovky budete také potřebovat, pokud si budete chtít nastavit ověření obličejem. Klepněte na Zrušit a poté si nastavte PIN nebo zvolte jiný typ zámku obrazovky."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="device" msgid="5844241782080551234">"Ochraňte své zařízení pomocí zámku obrazovky, aby ho v případě ztráty či odcizení nemohl použít nikdo cizí. Zámek obrazovky budete také potřebovat, pokud si budete chtít nastavit ověření obličejem. Klepněte na Zrušit a poté si nastavte PIN nebo zvolte jiný typ zámku obrazovky."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="default" msgid="7605324540825242057">"Ochraňte svůj telefon pomocí zámku obrazovky, aby ho v případě ztráty či odcizení nemohl použít nikdo cizí. Zámek obrazovky budete také potřebovat, pokud si budete chtít nastavit ověření obličejem. Klepněte na Zrušit a poté si nastavte PIN nebo zvolte jiný typ zámku obrazovky."</string>
    <string name="lock_screen_pin_skip_title" msgid="1197562382655681444">"Přeskočit nastavení PINu?"</string>
    <string name="lock_screen_password_skip_title" msgid="5016051613576694070">"Přeskočit nastavení hesla?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="5233245002352020859">"Přeskočit nastavení gesta?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="1195743489835505376">"Nastavit zámek obrazovky"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="4014607378328187567">"Hotovo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="1863561601428695160">"Jejda, to není senzor."</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="2989019978041986175">"Dotkněte se senzoru na zadní straně telefonu. Použijte ukazováček."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="3618021988442639280">"Registrace nebyla dokončena"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="2942551158278899627">"Bylo dosaženo časového limitu registrace otisku prstu. Zkuste to znovu."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="3624760637222239293">"Registrace otisku prstu nefungovala. Zkuste to znovu nebo použijte jiný prst."</string>
    <string name="fingerprint_enroll_button_add" msgid="6317978977419045463">"Přidat další"</string>
    <string name="fingerprint_enroll_button_next" msgid="6247009337616342759">"Další"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="2624905914239271751">"Kromě odemknutí telefonu můžete svůj otisk prstu použít také k autorizaci nákupů a přístupu aplikací. "<annotation id="url">"Další informace"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="7846871823167357942">" Možnost zámku obrazovky je zakázána. Další informace vám sdělí administrátor vaší organizace. "<annotation id="admin_details">"Další podrobnosti"</annotation>\n\n"Otisk prstu můžete i nadále používat k autorizaci nákupů a přístupu k aplikacím. "<annotation id="url">"Další informace"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="1888772560642539718">"Zvedněte prst a přiložte ho na senzor znovu."</string>
    <string name="fingerprint_add_max" msgid="1020927549936895822">"Maximální počet otisků prstů, které lze přidat: <xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="fingerprint_intro_error_max" msgid="6864066984678078441">"Přidali jste maximální počet otisků prstů"</string>
    <string name="fingerprint_intro_error_unknown" msgid="1905692132326523040">"Další otisky prstů nelze přidat"</string>
    <string name="fingerprint_last_delete_title" msgid="6410310101247028988">"Odstranit všechny otisky prstů?"</string>
    <string name="fingerprint_delete_title" msgid="1368196182612202898">"Odstranit <xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>"</string>
    <string name="fingerprint_delete_message" msgid="8597787803567398131">"Chcete tento otisk prstu smazat?"</string>
    <string name="fingerprint_last_delete_message" msgid="7852321001254275878">"Otisky prstů již nebude možné používat k odemykání telefonu, autorizaci nákupů ani přihlašování do aplikací."</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="6521520787746771912">"Otisky prstů již 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="fingerprint_last_delete_confirm" msgid="2634726361059274289">"Ano, odstranit"</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Šifrování"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Šifrovat tablet"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Šifrovat telefon"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Šifrováno"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="503014594435731275">"Své účty, nastavení, stažené aplikace a jejich data, média a další soubory můžete zašifrovat. Pokud tablet zašifrujete a nastavili jste zámek obrazovky (bezpečnostní gesto, číselný kód PIN nebo heslo), bude třeba jej při každém zapnutí dešifrovat odemknutím obrazovky. Dešifrování lze provést pouze obnovením továrních dat, kterým vymažete všechna svá data.\n\nŠifrování trvá hodinu nebo i déle. Šifrování je třeba zahájit s plně nabitou baterií a tablet je třeba mít během procesu zapojený do zásuvky. Pokud šifrování přerušíte, přijdete o některá nebo všechna svá data."</string>
    <string name="crypt_keeper_desc" product="default" msgid="2579929266645543631">"Své účty, nastavení, stažené aplikace a jejich data, média a další soubory můžete zašifrovat. Pokud telefon zašifrujete a nastavili jste zámek obrazovky (bezpečnostní gesto, číselný kód PIN nebo heslo), bude třeba jej při každém zapnutí dešifrovat odemknutím obrazovky. Jediným dalším způsobem dešifrování je obnovení továrních nastavení, kterým vymažete všechna svá data.\n\nŠifrování trvá hodinu nebo i déle. Šifrování je potřeba zahájit s nabitou baterií a během šifrování je potřeba ponechat telefon připojený ke zdroji napájení. Pokud šifrování přerušíte, přijdete o některá nebo všechna svá data."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Šifrovat tablet"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Šifrovat telefon"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Nabijte baterii a zkuste to znovu."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Připojte nabíječku a zkuste to znovu."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Chybí heslo nebo kód PIN zámku obrazovky"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Před začátkem šifrování musíte nastavit kód PIN nebo heslo zámku obrazovky."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Zašifrovat?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="517662068757620756">"Zašifrování je nevratné, a pokud ho přerušíte, budou vaše data ztracena. Šifrování trvá hodinu i déle. Během této doby bude tablet několikrát restartován."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="287503113671320916">"Zašifrování je nevratné, a pokud ho přerušíte, budou vaše data ztracena. Šifrování trvá hodinu i více. Během této doby bude telefon několikrát restartován."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Šifrování"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Počkejte prosím, než bude tablet zašifrován. Dokončeno: <xliff:g id="PERCENT">^1</xliff:g> %"</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Počkejte prosím, než bude telefon zašifrován. Dokončeno: <xliff:g id="PERCENT">^1</xliff:g> %"</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="1655047311546745695">"Počkejte prosím, než bude tablet zašifrován. Zbývající čas: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="1862964662304683072">"Počkejte prosím, než bude telefon zašifrován. Zbývající čas: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="556504311511212648">"Chcete-li tablet odemknout, vypněte jej a poté jej znovu zapněte."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="1794353635603020327">"Chcete-li telefon odemknout, vypněte jej a poté jej znovu zapněte."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"Upozornění: Po <xliff:g id="COUNT">^1</xliff:g> dalších neúspěšných pokusech o odemknutí bude zařízení vymazáno!"</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Zadejte heslo"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Šifrování se nezdařilo"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="8219375738445017266">"Šifrování bylo přerušeno a nelze je dokončit. V důsledku toho již nebudou údaje v tabletu přístupné. \n\n Chcete-li tablet opět začít používat, je potřeba obnovit tovární nastavení. Po obnově budete moci v průběhu nastavení tabletu obnovit všechna data, která jsou zálohována v účtu Google."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3270131542549577953">"Šifrování bylo přerušeno a nelze je dokončit. V důsledku toho již nebudou údaje v telefonu přístupné. \n\nChcete-li telefon opět začít používat, je potřeba obnovit tovární nastavení. Po obnově budete moci v průběhu nastavení telefonu obnovit všechna data, která jsou zálohována v účtu Google."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="8759119849089795751">"Dešifrování se nezdařilo"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="840107296925798402">"Zadané heslo je správné, avšak data jsou poškozena.\n\nChcete-li tablet nadále používat, je nutné v něm obnovit tovární nastavení. Až budete tablet po obnově znovu nastavovat, bude možné obnovit veškerá data, která byla zálohována na váš účet Google."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="8843311420059663824">"Zadané heslo je správné, avšak data jsou poškozena.\n\nChcete-li telefon nadále používat, je nutné v něm obnovit tovární nastavení. Až budete telefon po obnově znovu nastavovat, bude možné obnovit veškerá data, která byla zálohována na váš účet Google."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Přepnout metodu zadávání"</string>
    <string name="suggested_lock_settings_title" msgid="8498743819223200961">"Zabezpečení telefonu"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="2296800316150748710">"Ochraňte tablet pomocí zámku obrazovky"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="7562847814806365373">"Ochraňte zařízení pomocí zámku obrazovky"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="1526355348444658181">"Ochraňte telefon pomocí zámku obrazovky"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="2174553391551398081">"Chcete-li odemknout, přidejte otisk prstu"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="5738274583658668124"></string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Zámek obrazovky"</string>
    <string name="lock_settings_picker_title_profile" msgid="8822511284992306796">"Zvolte pracovní zámek"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="90329443364067215">"Ochraňte svůj tablet"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="2399952075134938929">"Ochraňte své zařízení"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="1572244299605153324">"Chraňte svůj telefon"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1507307757032207572">"Pro ještě lepší zabezpečení nastavte záložní zámek obrazovky"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="8919671129189936210">"Aktivujte funkce ochrany zařízení a zabraňte tak ostatním v používání tabletu bez vašeho svolení. Vyberte zámek obrazovky, který chcete používat."</string>
    <string name="setup_lock_settings_picker_message" product="device" msgid="3787276514406353777">"Aktivujte funkce ochrany zařízení a zabraňte tak ostatním v jeho používání bez vašeho svolení. Vyberte zámek obrazovky, který chcete používat."</string>
    <string name="setup_lock_settings_picker_message" product="default" msgid="3692856437543730446">"Aktivujte funkce ochrany zařízení a zabraňte tak ostatním v používání telefonu bez vašeho svolení. Vyberte zámek obrazovky, který chcete používat."</string>
    <string name="lock_settings_picker_fingerprint_message" msgid="4755230324778371292">"Zvolte záložní metodu zámku obrazovky"</string>
    <string name="lock_settings_picker_face_message" msgid="197106534637556054">"Zvolte záložní metodu zámku obrazovky"</string>
    <string name="setup_lock_settings_options_button_label" msgid="8511153243629402929">"Možnosti zámku obrazovky"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="5058207955455973917">"Možnosti zámku obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Zámek obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5967714169972542586">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / Ihned po spánku"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_after_timeout" msgid="4696710373399258413">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / <xliff:g id="TIMEOUT_STRING">%2$s</xliff:g> po spánku"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="124176557311393483">"Zámek prac. profilu"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Změna zámku obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Změnit nebo deaktivovat bezpečnostní gesto, kód PIN nebo heslo"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Vyberte způsob uzamknutí obrazovky"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Žádný"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Přejetí prstem"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Žádné zabezpečení"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Gesto"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Střední zabezpečení"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Střední až vysoké zabezpečení"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Heslo"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Vysoké zabezpečení"</string>
    <string name="unlock_set_do_later_title" msgid="4894767558414979243">"Teď ne"</string>
    <string name="current_screen_lock" msgid="4104091715420072219">"Aktuální zámek obrazovky"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4939057588092120368">"Otisk prstu a gesto"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="8010746824051056986">"Otisk prstu a PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="7351131075806338634">"Otisk prstu a heslo"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="1441077909803666681">"Pokračovat bez otisku prstu"</string>
    <string name="fingerprint_unlock_title" msgid="2826226740306003991">"Zařízení můžete odemknout otiskem prstu. Z bezpečnostních důvodů tato možnost vyžaduje záložní zámek obrazovky."</string>
    <string name="face_unlock_set_unlock_pattern" msgid="8792301636367000123">"Ověření pomocí obličeje a gesta"</string>
    <string name="face_unlock_set_unlock_pin" msgid="1196620299595657479">"Ověření pomocí obličeje a kódu PIN"</string>
    <string name="face_unlock_set_unlock_password" msgid="223117276773907474">"Ověření pomocí obličeje a hesla"</string>
    <string name="face_unlock_skip_face" msgid="6362883392838482791">"Pokračovat bez ověření pomocí obličeje"</string>
    <string name="face_unlock_title" msgid="9042382084472444316">"Zařízení můžete odemknout pomocí obličeje. Z bezpečnostních důvodů tato možnost vyžaduje záložní zámek obrazovky."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2051593894736282302">"Zakázáno administrátorem, zásadami šifrování nebo úložištěm pověření"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Žádná"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Přejetí prstem"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Gesto"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Heslo"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="7893457665921363009">"Po nastavení zámku obrazovky můžete v Nastavení &gt; Zabezpečení nastavit také otisk prstu."</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Vypnout zámek obrazovky"</string>
    <string name="unlock_disable_frp_warning_title" msgid="264008934468492550">"Odstranit ochranu zařízení?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="5507136301904313583">"Odstranit ochranu profilu?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="8869767290771023461">"Bez bezpečnostního gesta nebudou funkce ochrany zařízení fungovat."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2986105377420905314">"Bez gesta nebudou funkce ochrany zařízení fungovat.<xliff:g id="EMPTY_LINE">

</xliff:g>Ze zařízení budou odstraněny i uložené otisky prstů, a tak nebudete moci odemykat telefon, potvrzovat nákupy ani se přihlašovat do aplikací."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="586996206210265131">"Bez kódu PIN nebudou funkce ochrany zařízení fungovat."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="3370462835533123695">"Bez kódu PIN nebudou funkce ochrany zařízení fungovat.<xliff:g id="EMPTY_LINE">

</xliff:g>Ze zařízení budou odstraněny i uložené otisky prstů, a tak nebudete moci odemykat telefon, potvrzovat nákupy ani se přihlašovat do aplikací."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="5420612686852555537">"Bez hesla nebudou funkce ochrany zařízení fungovat."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="3595476296430536798">"Bez hesla nebudou funkce ochrany zařízení fungovat.<xliff:g id="EMPTY_LINE">

</xliff:g>Ze zařízení budou odstraněny i uložené otisky prstů, a tak nebudete moci odemykat telefon, potvrzovat nákupy ani se přihlašovat do aplikací."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="1550718040483548220">"Bez zámku obrazovky nebudou funkce ochrany zařízení fungovat."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="3679351662094349506">"Bez zámku obrazovky nebudou funkce ochrany zařízení fungovat.<xliff:g id="EMPTY_LINE">

</xliff:g>Ze zařízení budou odstraněny i uložené otisky prstů, a tak nebudete moci odemykat telefon, potvrzovat nákupy ani se přihlašovat do aplikací."</string>
    <string name="unlock_disable_frp_warning_content_pattern_profile" msgid="8682200103576359918">"Bez gesta nebudou funkce ochrany profilu fungovat."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile" msgid="6718155854303231675">"Bez gesta nebudou funkce ochrany profilu fungovat.<xliff:g id="EMPTY_LINE">

</xliff:g>Z profilu budou odstraněny i uložené otisky prstů, a tak nebudete moci odemykat profil, potvrzovat nákupy ani se přihlašovat do aplikací."</string>
    <string name="unlock_disable_frp_warning_content_pin_profile" msgid="7790688070593867767">"Bez kódu PIN nebudou funkce ochrany profilu fungovat."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile" msgid="4209564603132870532">"Bez kódu PIN nebudou funkce ochrany profilu fungovat.<xliff:g id="EMPTY_LINE">

</xliff:g>Z profilu budou odstraněny i uložené otisky prstů, a tak nebudete moci odemykat profil, potvrzovat nákupy ani se přihlašovat do aplikací."</string>
    <string name="unlock_disable_frp_warning_content_password_profile" msgid="7569285520567674461">"Bez hesla nebudou funkce ochrany profilu fungovat."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile" msgid="2994300676764706047">"Bez hesla nebudou funkce ochrany profilu fungovat.<xliff:g id="EMPTY_LINE">

</xliff:g>Z profilu budou odstraněny i uložené otisky prstů, a tak nebudete moci odemykat profil, potvrzovat nákupy ani se přihlašovat do aplikací."</string>
    <string name="unlock_disable_frp_warning_content_unknown_profile" msgid="6984215718701688202">"Bez zámku obrazovky nebudou funkce ochrany profilu fungovat."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile" msgid="4994062501123299418">"Bez zámku obrazovky nebudou funkce ochrany profilu fungovat.<xliff:g id="EMPTY_LINE">

</xliff:g>Z profilu budou odstraněny i uložené otisky prstů, a tak nebudete moci odemykat profil, potvrzovat nákupy ani se přihlašovat do aplikací."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="7075138677177748705">"Ano, odstranit"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Změna bezpečnostního gesta"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Změna bezpečnostního kódu PIN"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Změnit bezpečnostní heslo"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="7529087063617325912">"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="4195620619469851350">"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="428655972363263817">"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="6275441987228550440">"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="2219711062197089783">"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="4277765862798876826">"Vaše data budou smazána"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="1688030823464420974">"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="5350785938296254352">"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="6208035114731421034">"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="7851504071368235547">"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="4049024921333961715">"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="4660886542496781672">"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="2437716252059050291">"Pokud při příštím pokusu zadáte nesprávné gesto, váš pracovní profil a přidružená data budou smazána"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="5799931839127476913">"Pokud při příštím pokusu zadáte nesprávný PIN, váš pracovní profil a přidružená data budou smazána"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="6786586046975042158">"Pokud při příštím pokusu zadáte nesprávné heslo, váš pracovní profil a přidružená data budou smazána"</string>
    <string name="lock_failed_attempts_now_wiping_device" msgid="5047439819181833824">"Příliš mnoho neplatných pokusů. Data v tomto zařízení budou smazána."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="6188180643494518001">"Příliš mnoho neplatných pokusů. Tento uživatel bude smazán."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="1745475043685915442">"Příliš mnoho neplatných pokusů. Tento pracovní profil a přidružená data budou smazána."</string>
    <string name="lock_failed_attempts_now_wiping_dialog_dismiss" msgid="8246716090548717312">"Zavřít"</string>
    <plurals name="lockpassword_password_too_short" formatted="false" msgid="1957883871187697796">
      <item quantity="few">Musí obsahovat alespoň <xliff:g id="COUNT_1">%d</xliff:g> znaky</item>
      <item quantity="many">Musí obsahovat alespoň <xliff:g id="COUNT_1">%d</xliff:g> znaku</item>
      <item quantity="other">Musí obsahovat alespoň <xliff:g id="COUNT_1">%d</xliff:g> znaků</item>
      <item quantity="one">Musí obsahovat alespoň <xliff:g id="COUNT_0">%d</xliff:g> znak</item>
    </plurals>
    <plurals name="lockpassword_pin_too_short" formatted="false" msgid="5019935246875659237">
      <item quantity="few">PIN musí obsahovat alespoň <xliff:g id="COUNT_1">%d</xliff:g> číslice</item>
      <item quantity="many">PIN musí obsahovat alespoň <xliff:g id="COUNT_1">%d</xliff:g> číslice</item>
      <item quantity="other">PIN musí obsahovat alespoň <xliff:g id="COUNT_1">%d</xliff:g> číslic</item>
      <item quantity="one">PIN musí obsahovat alespoň <xliff:g id="COUNT_0">%d</xliff:g> číslici</item>
    </plurals>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Pokračovat"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="4581209996591221075">
      <item quantity="few">Musí obsahovat méně než <xliff:g id="NUMBER_1">%d</xliff:g> znaky</item>
      <item quantity="many">Musí obsahovat méně než <xliff:g id="NUMBER_1">%d</xliff:g> znaku</item>
      <item quantity="other">Musí obsahovat méně než <xliff:g id="NUMBER_1">%d</xliff:g> znaků</item>
      <item quantity="one">Musí obsahovat méně než <xliff:g id="NUMBER_0">%d</xliff:g> znak</item>
    </plurals>
    <plurals name="lockpassword_pin_too_long" formatted="false" msgid="185568652740755131">
      <item quantity="few">Musí obsahovat méně než <xliff:g id="NUMBER_1">%d</xliff:g> číslice</item>
      <item quantity="many">Musí obsahovat méně než <xliff:g id="NUMBER_1">%d</xliff:g> číslice</item>
      <item quantity="other">Musí obsahovat méně než <xliff:g id="NUMBER_1">%d</xliff:g> číslic</item>
      <item quantity="one">Musí obsahovat méně než <xliff:g id="NUMBER_0">%d</xliff:g> číslici</item>
    </plurals>
    <string name="lockpassword_pin_contains_non_digits" msgid="7284664023164191198">"PIN smí obsahovat pouze číslice 0 až 9."</string>
    <string name="lockpassword_pin_recently_used" msgid="1401569207976460727">"Administrátor zařízení nedovoluje použití nedávno použitého kódu PIN"</string>
    <string name="lockpassword_pin_blacklisted_by_admin" msgid="8563366383328811472">"Obvyklé kódy PIN jsou blokovány administrátorem IT. Použijte jiný PIN."</string>
    <string name="lockpassword_illegal_character" msgid="8049611046639943217">"Heslo nesmí obsahovat neplatné znaky."</string>
    <string name="lockpassword_password_requires_alpha" msgid="3036589522150097731">"Heslo musí obsahovat alespoň jedno písmeno."</string>
    <string name="lockpassword_password_requires_digit" msgid="5140062925787058765">"Heslo musí obsahovat alespoň jednu číslici."</string>
    <string name="lockpassword_password_requires_symbol" msgid="5944350865681510893">"Heslo musí obsahovat alespoň jeden symbol."</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="9013132344745898400">
      <item quantity="few">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> písmena</item>
      <item quantity="many">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> písmena</item>
      <item quantity="other">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> písmen</item>
      <item quantity="one">Heslo musí obsahovat alespoň 1 písmeno</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="2626327674921055486">
      <item quantity="few">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> malá písmena</item>
      <item quantity="many">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> malého písmena</item>
      <item quantity="other">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> malých písmen</item>
      <item quantity="one">Heslo musí obsahovat alespoň 1 malé písmeno</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="7860796359913920356">
      <item quantity="few">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> velká písmena</item>
      <item quantity="many">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> velkého písmena</item>
      <item quantity="other">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> velkých písmen</item>
      <item quantity="one">Heslo musí obsahovat alespoň 1 velké písmeno</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="1967587658356336828">
      <item quantity="few">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> číslice</item>
      <item quantity="many">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> číslice</item>
      <item quantity="other">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> číslic</item>
      <item quantity="one">Heslo musí obsahovat alespoň 1 číslici</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="6751305770863640574">
      <item quantity="few">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> speciální symboly</item>
      <item quantity="many">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> speciálního symbolu</item>
      <item quantity="other">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> speciálních symbolů</item>
      <item quantity="one">Heslo musí obsahovat alespoň 1 speciální symbol</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="4440596998172043055">
      <item quantity="few">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> znaky jiné než písmeno</item>
      <item quantity="many">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> znaku jiného než písmeno</item>
      <item quantity="other">Heslo musí obsahovat alespoň <xliff:g id="COUNT">%d</xliff:g> znaků jiných než písmeno</item>
      <item quantity="one">Heslo musí obsahovat alespoň 1 znak jiný než písmeno</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="942665351220525547">"Administrátor zařízení neumožňuje použít heslo, které jste použili nedávno"</string>
    <string name="lockpassword_password_blacklisted_by_admin" msgid="9105101266246197027">"Obvyklá hesla jsou blokována administrátorem IT. Použijte jiné heslo."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="680765285206990584">"Posloupnost rostoucích, klesajících nebo opakujících se číslic není povolena"</string>
    <string name="lockpassword_confirm_label" msgid="8176726201389902380">"Potvrdit"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Zrušit"</string>
    <string name="lockpassword_clear_label" msgid="5724429464960458155">"Vymazat"</string>
    <string name="lockpassword_credential_changed" msgid="581649578639853343">"Zámek obrazovky se už změnil. Zadejte nový zámek obrazovky."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Zrušit"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Další"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Nastavení je dokončeno."</string>
    <string name="manage_device_admin" msgid="537804979483211453">"Aplikace pro správu zařízení"</string>
    <string name="number_of_device_admins_none" msgid="7185056721919496069">"Žádné aktivní aplikace"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="3361891840111523393">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> aktivní aplikace</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> aktivní aplikace</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aktivních aplikací</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> aktivní aplikace</item>
    </plurals>
    <string name="manage_trust_agents" msgid="4629279457536987768">"Agenti důvěry"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Před použitím nejdříve nastavte zámek obrazovky"</string>
    <string name="manage_trust_agents_summary" msgid="1475819820389620546">"Žádné"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="3935182396726101824">
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aktivní agenti důvěry</item>
      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> aktivního agenta důvěry</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aktivních agentů důvěry</item>
      <item quantity="one">1 aktivní agent důvěry</item>
    </plurals>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Zapnout Bluetooth"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Umožňuje spravovat připojení, nastavit název zařízení a viditelnost"</string>
    <string name="bluetooth_pairing_request" msgid="2605098826364694673">"Spárovat se zařízením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="418124944140102021">"Párovací kód Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Zadejte párovací kód a poté stiskněte Return nebo Enter."</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"Kód PIN obsahuje písmena nebo symboly"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Obvykle 0000 nebo 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="7849359451584101077">"Je nutné zadat 16 číslic."</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Tento kód PIN bude možná nutné zadat i v dalším zařízení."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Tento přístupový klíč bude možná nutné zadat i v druhém zařízení."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Párování se zařízením:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Zkontrolujte, zda zařízení zobrazuje tento přístupový klíč:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"Ze zařízení:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Spárovat s tímto zařízením?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Párování se zařízením:<xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Zadejte:<xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g> a poté stiskněte klávesu Return nebo Enter."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="9082518313285787097">"Povolit přístup ke kontaktům a historii volání"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_connecting_error_message" msgid="1397388344342081090">"K zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> se nelze připojit."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Vyhledat zařízení"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Obnovit"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Hledání…"</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Nastavení zařízení"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Spárované zařízení"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Připojení k internetu"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Klávesnice"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Kontakty a historie volání"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Párovat s tímto zařízením?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Sdílet telefonní seznam?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> žádá o přístup k vašim kontaktům a historii volání."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="8451248193517851958">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> žádá o spárování s Bluetooth. Po spojení bude mít přístup ke kontaktům a historii volání."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="1617401232446299411">"Dostupná zařízení"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"Nejsou dostupná žádná zařízení"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Připojit"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Odpojit"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Párovat a připojit"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Zrušit párování"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Odpojit a zrušit párování"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Možnosti"</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Rozšířené nastavení"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Rozšířené nastavení Bluetooth"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Když je zapnuté připojení Bluetooth, zařízení může komunikovat s ostatními zařízeními Bluetooth v okolí."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="824285504325592644">"Když je zapnuté připojení Bluetooth, zařízení může komunikovat s ostatními zařízeními Bluetooth v okolí.\n\nZa účelem vylepšení funkcí mohou aplikace a služby nadále vyhledávat zařízení v okolí, i když je Bluetooth vypnuté. Lze tak například vylepšit funkce založené na poloze. Toto chování můžete změnit v "<annotation id="link">"nastavení vyhledávání"</annotation>"."</string>
    <string name="ble_scan_notify_text" msgid="1295915006005700650">"Za účelem zvýšení přesnosti určování polohy mohou systémové aplikace a služby neustále vyhledávat zařízení Bluetooth. Toto chování můžete změnit v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastavení vyhledávání<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_failed" msgid="4500234659813241053">"Nelze se připojit. Zkuste to znovu."</string>
    <string name="device_details_title" msgid="6576953269221085300">"Podrobnosti o zařízení"</string>
    <string name="bluetooth_device_mac_address" msgid="2513724313558236181">"Adresa Bluetooth zařízení: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="38467834196432400">"Zapomenout zařízení?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="9087609557757135712">"Telefon již nebude spárován se zařízením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="tablet" msgid="7785695793007576501">"Tablet již nebude spárován se zařízením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="device" msgid="251257782642157557">"Zařízení již nebude spárováno se zařízením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="3829370108973879006">"Zapomenout zařízení"</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Připojit k síti…"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojeno od zvuku médií."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojeno od zvuku sady handsfree."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojeno od vstupního zařízení."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Internetové připojení pomocí zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojeno."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="8355910926439312604">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojeno od sdíleného internetového připojení tabletu."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="6251611115860359886">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude odpojeno od sdíleného internetového připojení telefonu."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Spárované zařízení Bluetooth"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Připojit"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Umožňuje připojení zařízení s rozhraním Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Použít pro"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Přejmenovat"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Povolit přích. přenosy souborů"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="6436258151814414028">"Připojeno k zařízení za účelem přístupu k internetu"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1322694224800769308">"Místní internetové připojení je sdíleno se zařízením"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Nastavení doku"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Použít zvuk doku"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Jako telefon pro hlasitý poslech"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Pro hudbu a média"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Zapamatovat nastavení"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="6752690395207847881">"Maximum připojených audiozařízení Bluetooth"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="5936561749790095473">"Vyberte maximální počet připojených audiozařízení Bluetooth"</string>
    <string name="wifi_display_settings_title" msgid="8740852850033480136">"Odesílání"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Povolit bezdrátové zobrazení"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"V okolí nebyla nalezena žádná zařízení."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Připojování"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Připojené"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"Používá se"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Není k dispozici"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Nastavení displeje"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Možnosti bezdrátového displeje"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Odstranit"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Hotovo"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Název"</string>
    <string name="wifi_band_24ghz" msgid="852929254171856911">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="6433822023268515117">"5 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8404345621836792112">"Přihlásit se"</string>
    <string name="wifi_tap_to_sign_in" msgid="6990161842394669054">"Klepnutím sem se přihlásíte do sítě"</string>
    <string name="tx_link_speed" msgid="6139577455916971837">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="rx_link_speed" msgid="5729003360923133988">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="wifi_ask_enable" msgid="2795469717302060104">"Aplikace <xliff:g id="REQUESTER">%s</xliff:g> chce zapnout Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="728366570145493573">"Aplikace <xliff:g id="REQUESTER">%s</xliff:g> chce vypnout Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="6029838014407791341">"Ověření bajtkódu aplikací k ladění"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="2250352478065428399">"Povolit nástroji ART ověřovat bajtkód aplikací k ladění"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Povolit výměnu dat, pokud se tablet dotkne jiného zařízení"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Povolit výměnu dat, pokud se telefon dotkne jiného zařízení"</string>
    <string name="nfc_disclaimer_title" msgid="4364003873202264039">"Zapnout NFC"</string>
    <string name="nfc_disclaimer_content" msgid="5566907911915158075">"Technologie NFC vyměňuje data mezi tímto zařízením a dalšími zařízeními a cíli v okolí, jako jsou platební terminály, systémy kontroly přístupu a interaktivní reklamy či značky."</string>
    <string name="nfc_secure_settings_title" msgid="150400737244061585">"Zabezpečení NFC"</string>
    <string name="nfc_secure_toggle_summary" product="default" msgid="2135032222065627938">"Povolit platby a přenosy přes NFC pouze při odemknuté obrazovce"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Přenos obsahu aplikace prostřednictvím NFC je připraven"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Vypnuto"</string>
    <string name="nfc_disabled_summary" msgid="3507017304297395467">"Není k dispozici, protože je vypnutá funkce NFC"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="1810540319385192758">"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_quick_toggle_title" msgid="8850161330437693895">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Zapnout Wi-Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi-Fi"</string>
    <string name="wifi_settings_master_switch_title" msgid="4746267967669683259">"Používat Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Nastavení Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi-Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Umožňuje nastavit a spravovat přístupové body bezdrátové sítě"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Vyberte síť Wi-Fi"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Zapínání Wi‑Fi…"</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Vypínání Wi‑Fi…"</string>
    <string name="wifi_error" msgid="3207971103917128179">"Chyba"</string>
    <string name="wifi_sap_no_channel_error" msgid="3108445199311817111">"V této zemi není pásmo 5 GHz k dispozici"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"Při režimu Letadlo"</string>
    <string name="wifi_notify_open_networks" msgid="76298880708051981">"Oznamovat veřejné sítě"</string>
    <string name="wifi_notify_open_networks_summary" msgid="2761326999921366960">"Zobrazit oznámení, když je dostupná kvalitní veřejná síť"</string>
    <string name="wifi_wakeup" msgid="8815640989361538036">"Zapínat Wi-Fi automaticky"</string>
    <string name="wifi_wakeup_summary" msgid="2530814331062997163">"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="7494539594649967699">"Nedostupné, protože je vypnuto určování polohy. Zapněte "<annotation id="link">"určování polohy"</annotation>"."</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="7247227922074840445">"Nedostupné, protože je vypnuto vyhledávání Wi-Fi"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="108339002136866897">"Chcete-li se automaticky připojovat, je třeba vybrat poskytovatele hodnocení sítí"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Ignorovat slabá připojení"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7016103106105907127">"Nepoužívat síť Wi-Fi, pokud nemá dostatečně kvalitní internetové připojení"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="1644292503152790501">"Použít jen sítě s dobrým připojením k internetu"</string>
    <string name="use_open_wifi_automatically_title" msgid="6851951242903078588">"Připojovat se k otevřeným sítím"</string>
    <string name="use_open_wifi_automatically_summary" msgid="2982091714252931713">"Automaticky se připojovat ke kvalitním veřejným sítím"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="593964217679325831">"Chcete-li se automaticky připojovat, je třeba vybrat poskytovatele hodnocení sítí"</string>
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled" msgid="8472122600853650258">"Chcete-li se automaticky připojovat, je třeba vybrat kompatibilního poskytovatele hodnocení sítí"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Instalace certifikátů"</string>
    <string name="wifi_scan_notify_text" msgid="5544778734762998889">"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í<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="3426075479272242098">"Chcete-li 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í<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="7104867814641144485">"Tuto zprávu příště nezobrazovat"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Wi-Fi aktivní i v režimu spánku"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"Wi-Fi aktivní i v režimu spánku"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Při změně nastavení se vyskytl problém"</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Zlepšit výkonnost"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimalizace Wi-Fi"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Minimalizovat využívání baterie při zapnuté síti Wi-Fi"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Omezit využití baterie sítí Wi‑Fi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="8593144541347373394">"Pokud síť Wi‑Fi ztratí přístup k internetu, přepnout na mobilní data"</string>
    <string name="wifi_cellular_data_fallback_title" msgid="8753386877755616476">"Automaticky přepínat na mobilní data"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="1403505355490119307">"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="6234851776910938957">"Přidat síť"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2913345003906899146">"Předvolby Wi-Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="646393113104367290">"Wi‑Fi se zapíná automaticky znovu"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="2782566279864356713">"Wi‑Fi se nezapíná automaticky znovu"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Sítě Wi-Fi"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Další možnosti"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Wi‑Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Vyhledávání"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Rozšířené nastavení"</string>
    <string name="wifi_menu_configure" msgid="6150926852602171938">"Konfigurovat"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Připojit k síti"</string>
    <string name="wifi_menu_remember" msgid="8814185749388713796">"Zapamatovat síť"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Odstranit záznam sítě"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Upravit síť"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Chcete-li zobrazit dostupné sítě, zapněte Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Vyhledávání sítí Wi-Fi…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="7322372065475939129">"Nemáte oprávnění ke změně sítě Wi-Fi."</string>
    <string name="wifi_more" msgid="3195296805089107950">"Další"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Automat. nastavení (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="3815269816331500375">"Zapnout vyhledávání Wi-Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="6352918945128328916">"Chcete-li automaticky zapínat Wi-Fi, nejprve zapněte vyhledávání Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="3155631874578023647">"Vyhledávání Wi‑Fi 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="1364287182804820646">"Zapnout"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="5527653791584018157">"Vyhledávání Wi‑Fi je zapnuto"</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Rozšířené možnosti"</string>
    <string name="wifi_advanced_toggle_description_expanded" msgid="2380600578544493084">"Rozbalovací seznam Rozšířené možnosti. Dvojitým klepnutím jej sbalíte."</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="1463812308429197263">"Rozbalovací seznam Rozšířené možnosti. Dvojitým klepnutím jej rozbalíte."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Název sítě"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Zadejte SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Zabezpečení"</string>
    <string name="wifi_hidden_network" msgid="973162091800925000">"Skrytá síť"</string>
    <string name="wifi_hidden_network_warning" msgid="6674068093531603452">"Pokud směrovač nevysílá ID sítě, ale v budoucnu jej chcete k síti 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í směrovače tím nezměníte."</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Síla signálu"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Stav"</string>
    <string name="tx_wifi_speed" msgid="2994278184097786511">"Rychlost odkazu pro přenos"</string>
    <string name="rx_wifi_speed" msgid="7206089638282839236">"Rychlost odkazu k přijímání"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Frekvence"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"IP adresa"</string>
    <string name="passpoint_label" msgid="6381371313076009926">"Uloženo pomocí"</string>
    <string name="passpoint_content" msgid="8447207162397870483">"<xliff:g id="NAME">%1$s</xliff:g> – identifikační údaje"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"Metoda EAP"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Ověření Phase 2"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"Certifikát CA"</string>
    <string name="wifi_eap_domain" msgid="8471124344218082064">"Doména"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Certifikát uživatele"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identita"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Anonymní identita"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Heslo"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Zobrazovat heslo"</string>
    <string name="wifi_ap_band_config" msgid="1611826705989117930">"Vybrat pásmo přístupového bodu"</string>
    <string name="wifi_ap_choose_auto" msgid="2677800651271769965">"Automatické"</string>
    <string name="wifi_ap_choose_2G" msgid="8724267386885036210">"Pásmo 2,4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8813128641914385634">"Pásmo 5,0 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2501070491623803139">"Upřednostňované pásmo 5,0 GHz"</string>
    <string name="wifi_ap_2G" msgid="8378132945192979364">"2,4 GHz"</string>
    <string name="wifi_ap_5G" msgid="4020713496716329468">"5,0 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="3476254666116431650">"Vyberte alespoň jedno pásmo pro hotspot Wi-Fi:"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"Nastavení IP adresy"</string>
    <string name="wifi_privacy_settings" msgid="5500777170960315928">"Ochrana soukromí"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="1539659414108891004">"Náhodná adresa MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="8674936581557695411">"Přidat zařízení"</string>
    <string name="wifi_dpp_center_qr_code" msgid="6244508369721032655">"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="4794621158747044107">"Naskenovat QR kód"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="4371771604088014396">"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="8096370383700478819">"Naskenováním QR kódu se připojíte k síti Wi-Fi"</string>
    <string name="wifi_dpp_share_wifi" msgid="9065890131734833809">"Sdílení sítě Wi-Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="5854392840857123065">"Chcete-li se připojit k síti <xliff:g id="SSID">%1$s</xliff:g>, naskenujte tento QR kód a sdílejte heslo"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="4436318319178361543">"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_could_not_detect_valid_qr_code" msgid="641893675646330576">"QR kód se nepodařilo přečíst. Zadejte ho znovu."</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="3372757783382381044">"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="2829930473520603740">"Něco se pokazilo"</string>
    <string name="wifi_dpp_failure_timeout" msgid="5228320772245820458">"Zkontrolujte, zda je zařízení zapojeno, nabito a zapnuto"</string>
    <string name="wifi_dpp_failure_generic" msgid="8030831192606098356">"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="2643768115109632725">"Toto zařízení neumožňuje přidání sítě <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="2632966336733361805">"Zkontrolujte připojení a zkuste to znovu"</string>
    <string name="wifi_dpp_choose_network" msgid="7139308800110200281">"Vybrat síť"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4025269026652486605">"Chcete-li zařízení připojit, vyberte síť"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5459084866460319042">"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="7669684043486750097">"Wi‑Fi se sdílí se zařízením"</string>
    <string name="wifi_dpp_add_another_device" msgid="8415243205104666929">"Přidat další zařízení"</string>
    <string name="wifi_dpp_choose_different_network" msgid="4081965219206680361">"Vybrat jinou síť"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="1598945041477461501">"Zařízení se nepodařilo přidat"</string>
    <string name="wifi_dpp_device_found" msgid="8618134150169810107">"Bylo nalezeno zařízení"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="5579154298588011712">"Sdílení Wi‑Fi s tímto zařízením…"</string>
    <string name="wifi_dpp_connecting" msgid="7111851118215580428">"Připojování…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="762408459341741405">"Sdílet hotspot"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="8401802203867904622">"Potvrďte, že jste to vy"</string>
    <string name="wifi_dpp_wifi_password" msgid="4938294574591503213">"Heslo k Wi-Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="4120419278831581613">"Heslo k hotspotu: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_add_device" msgid="4072206063308645677">"Přidat zařízení"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="8898075663321081592">"Připojte se k této síti pomocí QR kódu"</string>
    <string name="retry" msgid="6472609612090877557">"Zkusit znovu"</string>
    <string name="wifi_shared" msgid="844142443226926070">"Sdílet s ostatními uživateli zařízení"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(nezměněno)"</string>
    <string name="wifi_unspecified" msgid="4917316464723064807">"Vyberte"</string>
    <string name="wifi_multiple_cert_added" msgid="3240743501460165224">"(Bylo přidáno několik certifikátů)"</string>
    <string name="wifi_use_system_certs" msgid="5270879895056893783">"Použít certifikáty systému"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="5160499244977160665">"Neposkytovat"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4266754430576348471">"Neověřovat"</string>
    <string name="wifi_do_not_validate_eap_server_warning" msgid="1787190245542586660">"Není určen žádný certifikát. Připojení nebude soukromé."</string>
    <string name="wifi_ssid_too_long" msgid="3474753269579895244">"Název sítě je příliš dlouhý."</string>
    <string name="wifi_no_domain_warning" msgid="5223011964091727376">"Zadejte doménu."</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WPS je k dispozici"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (WPS je k dispozici)"</string>
    <string name="wifi_carrier_connect" msgid="8174696557882299911">"Síť Wi-Fi operátora"</string>
    <string name="wifi_carrier_content" msgid="4634077285415851933">"Připojit přes: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnout vyhledávání sítí (kvůli lepšímu určení polohy i kvůli jiným účelům) a hledat sítě i v případě, že je vypnut modul Wi-Fi.\n\nChcete tuto možnost povolit všem aplikacím, které chtějí vyhledávat sítě?"</string>
    <!-- no translation found for wifi_scan_always_turn_on_message_unknown (6162424298483845679) -->
    <skip />
    <string name="wifi_scan_always_turnoff_message" msgid="5538901671131941043">"Chcete-li toto nastavení vypnout, přejděte do rozbalovací nabídky Rozšířené."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Povolit"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Zamítnout"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Chcete se přihlásit, abyste se mohli připojit?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"Aplikace <xliff:g id="APP_NAME">%1$s</xliff:g> vyžaduje, abyste se před připojením k síti přihlásili na webu."</string>
    <string name="wifi_hotspot_connect" msgid="5065506390164939225">"PŘIPOJIT"</string>
    <string name="no_internet_access_text" msgid="5926979351959279577">"Tato síť nemá přístup k internetu. Chcete zůstat připojeni?"</string>
    <string name="partial_connectivity_text" msgid="1287030663891772340">"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="4697314331614625075">"U této sítě se již nedotazovat"</string>
    <string name="lost_internet_access_title" msgid="5779478650636392426">"Síť Wi‑Fi nemá přístup k internetu"</string>
    <string name="lost_internet_access_text" msgid="9029649339816197345">"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="2262459569601190039">"Přepnout na mobilní data"</string>
    <string name="lost_internet_access_cancel" msgid="338273139419871110">"Zůstat na Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="7634876061262676255">"Již nikdy nezobrazovat"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Připojit"</string>
    <string name="wifi_turned_on_message" msgid="4432839393213448846">"Připojení Wi-Fi je zapnuto"</string>
    <!-- no translation found for wifi_connected_to_message (2265022072754345638) -->
    <skip />
    <string name="wifi_connecting" msgid="8760426806460651215">"Připojování…"</string>
    <!-- no translation found for wifi_disconnect (3445234285136039895) -->
    <skip />
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Připojení k síti se nezdařilo."</string>
    <string name="wifi_not_in_range_message" msgid="6616864204007424228">"Síť není v dosahu"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Odstranit"</string>
    <string name="wifi_modify" msgid="6100248070440710782">"Upravit"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Odstranění záznamu sítě se nezdařilo."</string>
    <string name="wifi_save" msgid="3331121567988522826">"Uložit"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Uložení sítě se nezdařilo."</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Zrušit"</string>
    <string name="wifi_forget_dialog_title" msgid="6224151903586192426">"Zapomenout síť?"</string>
    <string name="wifi_forget_dialog_message" msgid="2337060138532166680">"Všechna hesla této sítě budou smazána"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="6094679048871529675">
      <item quantity="few">%d sítě</item>
      <item quantity="many">%d sítě</item>
      <item quantity="other">%d sítí</item>
      <item quantity="one">1 síť</item>
    </plurals>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Rozšířené nastavení"</string>
    <string name="wifi_advanced_ssid_title" msgid="1552309166043760291">"SSID"</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Adresa MAC"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP adresa"</string>
    <string name="wifi_details_title" msgid="8954667664081737098">"Podrobnosti sítě"</string>
    <string name="wifi_details_subnet_mask" msgid="6720279144174924410">"Maska podsítě"</string>
    <string name="wifi_details_dns" msgid="8648826607751830768">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="6734119149106422148">"Adresy IPv6"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Uložené sítě"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="6480224551765489055">"Odběry"</string>
    <!-- no translation found for wifi_saved_access_points_tab (2659675386657663705) -->
    <skip />
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"Nastavení IP adresy"</string>
    <string name="wifi_advanced_not_available" msgid="5823045095444154586">"Rozšířená nastavení sítě Wi-Fi nejsou pro tohoto uživatele dostupná."</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Uložit"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Zrušit"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Zadejte platnou IP adresu."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Zadejte prosím platnou adresu brány."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Zadejte prosím platnou adresu DNS."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Zadejte prosím délku síťové předpony v rozsahu 0 až 32."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"Server DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"Server DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Brána"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Délka síťové předpony"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Wi‑Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Informace o zařízení"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Pamatovat si toto připojení"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Vyhledat zařízení"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Hledání…"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Přejmenovat zařízení"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Partnerská zařízení"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Uložené skupiny"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8491862096448192157">"Nelze připojit."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Zařízení se nepodařilo přejmenovat."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Odpojit?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Pokud se odpojíte, vaše spojení se zařízením <xliff:g id="PEER_NAME">%1$s</xliff:g> bude přerušeno."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Pokud se odpojíte, bude spojení se zařízením <xliff:g id="PEER_NAME">%1$s</xliff:g> a s <xliff:g id="PEER_COUNT">%2$s</xliff:g> dalšími zařízeními přerušeno."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Zrušit pozvánku?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Chcete zrušit pozvánku ke spojení s klientem <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Odstranit tuto skupinu?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"Wi‑Fi hotspot"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2199911382555864644">"Internet ani obsah není sdílen s dalšími zařízeními"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5936710887156133458">"Internetové připojení tohoto tabletu je sdíleno pomocí hotspotu"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="default" msgid="5556202634866621632">"Internetové připojení tohoto telefonu je sdíleno pomocí hotspotu"</string>
    <string name="wifi_hotspot_on_local_only_subtext" msgid="5017191966153008">"Aplikace sdílí obsah. Chcete-li sdílet připojení k internetu, vypněte hotspot a znovu jej zapněte"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="353306131026431089">"Není nastaveno žádné heslo"</string>
    <string name="wifi_hotspot_name_title" msgid="8237000746618636778">"Název hotspotu"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="3378299995508671967">"Zapínám hotspot <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>..."</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="3888672084861445362">"Ostatní zařízení se mohou připojit k hostpotu <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_hotspot_password_title" msgid="8676859981917573801">"Heslo hotspotu"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="1165801173359290681">"Pásmo přístupového bodu"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="4789553667374849566">"Pomocí hotspotu můžete vytvořit síť Wi‑Fi pro další zařízení. Hotspot poskytuje připojení k internetu pomocí vašeho mobilního datového připojení. Mohou být účtovány dodatečné poplatky za mobilní data."</string>
    <string name="wifi_hotspot_footer_info_local_only" msgid="857988412470694109">"Aplikace mohou vytvořit hotspot ke sdílení obsahu s okolními zařízeními."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="1590313508558948079">"Automatické vypnutí hotspotu"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="5858098059725925084">"Pokud nebudou připojena žádná zařízení, hotspot Wi-Fi se vypne"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Zapínání hotspotu…"</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Vypínání hotspotu…"</string>
    <string name="wifi_tether_enabled_subtext" msgid="7842111748046063857">"Síť <xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktivní"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Chyba přenosného hotspotu Wi-Fi"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Nastavit hotspot sítě Wi-Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Nastavení Wi‑Fi hotspotu"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5560680057727007011">"Hotspot AndroidAP WPA2 PSK"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"AndroidHotspot"</string>
    <string name="wifi_calling_settings_title" msgid="4102921303993404577">"Volání přes Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="5702964371483390024">"Rozšiřte volání pomocí Wi-Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="1331793267608673739">"Chcete-li rozšířit pokrytí, zapněte volání přes Wi-Fi"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Předvolby volání"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="7105195222267749226">"Předvolby volání"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="1565039047187685115">"Předvolba pro roaming"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (8642014873060687717) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="7800926602662078576">"Předvolba pro roaming"</string>
  <string-array name="wifi_calling_mode_choices">
    <item msgid="772621647207148279">"@*android:string/wfc_mode_wifi_preferred_summary"</item>
    <item msgid="2226422868199612072">"@*android:string/wfc_mode_cellular_preferred_summary"</item>
    <item msgid="7041954411163832397">"@*android:string/wfc_mode_wifi_only_summary"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="742988808283756263">"Wi-Fi"</item>
    <item msgid="7715869266611010880">"Mobilní"</item>
    <item msgid="2838022395783120596">"Pouze Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_without_wifi_only">
    <item msgid="4430473354160964286">"@*android:string/wfc_mode_wifi_preferred_summary"</item>
    <item msgid="5965810717958113109">"@*android:string/wfc_mode_cellular_preferred_summary"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="6132150507201243768">"Wi-Fi"</item>
    <item msgid="1118703915148755405">"Mobilní"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="9092988115148569860">"Pokud Wi-Fi není k dispozici, použít mobilní síť"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="240885549023046403">"Pokud mobilní síť nebude k dispozici, použít Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3688265826855460036">"Volání přes Wi‑Fi. Pokud bude signál Wi-Fi ztracen, hovor skončí."</string>
    <string name="wifi_calling_off_explanation" msgid="564780186974911501">"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="2329334487851497223"></string>
    <string name="emergency_address_title" msgid="932729250447887545">"Nouzová adresa"</string>
    <string name="emergency_address_summary" msgid="7751971156196115129">"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="3299567069152568958"><annotation id="url">"Další informace"</annotation>" o funkcích soukromého režimu DNS"</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="6845711858866828986">"Nastavení spravováno operátorem"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="7492509632478260955">"Aktivujte volání přes Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="1171403510313983983">"Zapněte volání přes Wi-Fi"</string>
    <string name="wifi_calling_not_supported" msgid="7878640438907807754">"Volání přes Wi‑Fi operátor %1$s nepodporuje"</string>
    <string name="carrier" msgid="5264014738689761132">"Operátor"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Displej"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Zvuk"</string>
    <string name="all_volume_title" msgid="4296957391257836961">"Hlasitost"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Hudební efekty"</string>
    <string name="ring_volume_title" msgid="5592466070832128777">"Hlasitost vyzvánění"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibrovat v tichém režimu"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Výchozí zvuk oznámení"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Vyzváněcí tón"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Oznámení"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Použije hlasitost příchozích hovorů také pro oznámení"</string>
    <string name="home_work_profile_not_supported" msgid="1357721012342357037">"Nepodporuje pracovní profily"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Výchozí zvuk oznámení"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Média"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Umožňuje nastavit hlasitost hudby a videí"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Budík"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Nastavení zvuku pro připojený dok"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Tóny při dotyku číselníku"</string>
    <string name="sound_effects_enable_title" msgid="4429690369187229592">"Zvuky při klepnutí"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Zvuk uzamčení obrazovky"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Potlačení hluku"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Hudba, video, hry a další média"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Vyzvánění a oznámení"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Oznámení"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Budíky"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Vypnout zvuk vyzvánění a oznámení"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Vypnout zvuk hudby a jiných médií"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Vypnout zvuk oznámení"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Vypnout zvuk budíků"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Dokovací stanice"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Nastavení doku"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Zvuk"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Nastavení připojeného stolního doku"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Nastavení připojeného doku do auta"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tablet není vložen do doku"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefon není vložen do doku"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Nastavení připojeného doku"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Dok nebyl nalezen"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Chcete-li nastavit zvuk doku, musíte tablet vložit do doku."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Chcete-li nastavit zvuk doku, musíte telefon vložit do doku."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Zvuk při vložení do doku"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Při vložení nebo vyjmutí tabletu z doku přehrát zvuk"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Přehrát zvuk při vkládání nebo vyjímání telefonu z doku"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="4308252722466813560">"Při vložení nebo vyjmutí tabletu z doku nepřehrávat zvuk"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="2034927992716667672">"Nepřehrávat zvuk při vkládání nebo vyjímání telefonu z doku"</string>
    <string name="account_settings" msgid="6403589284618783461">"Účty"</string>
    <string name="accessibility_category_work" msgid="4339262969083355720">"Účty s pracovním profilem – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="1263518850905945594">"Účty s osobním profilem"</string>
    <string name="accessibility_work_account_title" msgid="1231830766637939527">"Pracovní účet – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="2169071663029067826">"Osobní účet – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="1910951467596035063">"Vyhledávání"</string>
    <string name="display_settings" msgid="7965901687241669598">"Displej"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Autom. otočení obrazovky"</string>
    <string name="color_mode_title" msgid="9186249332902370471">"Barvy"</string>
    <string name="color_mode_option_natural" msgid="5013837483986772758">"Přirozené"</string>
    <string name="color_mode_option_boosted" msgid="8588223970257287524">"Zesílené"</string>
    <string name="color_mode_option_saturated" msgid="4569683960058798843">"Syté"</string>
    <string name="color_mode_option_automatic" msgid="7996505473528529568">"Adaptivní"</string>
    <string name="color_mode_summary_natural" msgid="6624188642920403099">"Používat pouze přesné barvy"</string>
    <string name="color_mode_summary_automatic" msgid="4669516973360709431">"Vyberte mezi jasnými a přesnými barvami"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Při otáčení tabletu automaticky přepínat orientaci"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Při otáčení telefonu automaticky přepínat orientaci"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Při otáčení tabletu automaticky přepínat orientaci"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Při otáčení telefonu automaticky přepínat orientaci"</string>
    <string name="brightness" msgid="8480105032417444275">"Úroveň jasu"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Jas"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Nastavení jasu displeje"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Adaptivní jas"</string>
    <string name="auto_brightness_summary_on" msgid="3519854265558828744">"Zapnuto"</string>
    <string name="auto_brightness_summary_off" msgid="2802336459335410626">"Vypnuto"</string>
    <string name="auto_brightness_summary_very_low" msgid="6483976609035853764">"Je preferován velmi nízký jas"</string>
    <string name="auto_brightness_summary_low" msgid="5609877905833960427">"Je preferován nízký jas"</string>
    <string name="auto_brightness_summary_default" msgid="7225666614394726845">"Je preferován výchozí jas"</string>
    <string name="auto_brightness_summary_high" msgid="7172304165631136027">"Je preferován vysoký jas"</string>
    <string name="auto_brightness_summary_very_high" msgid="979277812582279078">"Je preferován velmi vysoký jas"</string>
    <string name="auto_brightness_off_title" msgid="2996864829946190795">"Vypnuto"</string>
    <string name="auto_brightness_very_low_title" msgid="8252988638614126320">"Velmi nízká"</string>
    <string name="auto_brightness_low_title" msgid="1632186441514863377">"Nízká"</string>
    <string name="auto_brightness_default_title" msgid="936771997353506620">"Výchozí"</string>
    <string name="auto_brightness_high_title" msgid="2527853305981497345">"Vysoká"</string>
    <string name="auto_brightness_very_high_title" msgid="8867164854439331022">"Velmi vysoká"</string>
    <string name="auto_brightness_subtitle" msgid="6454652530864093466">"Preferovaná úroveň jasu"</string>
    <string name="auto_brightness_off_summary" msgid="7629228736838155268">"Neupravovat jas podle okolního světla"</string>
    <string name="auto_brightness_very_high_summary" msgid="4551003097086220709">"Zvýšené využití baterie"</string>
    <string name="auto_brightness_disclaimer" msgid="871436423746343406">"Optimalizovat jas podle okolního světla. I když je tato funkce zapnutá, můžete jas dočasně upravit."</string>
    <string name="auto_brightness_description" msgid="7310335517128283729">"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="display_white_balance_title" msgid="4093966473741329340">"Vyvážení bílé na obrazovce"</string>
    <!-- no translation found for adaptive_sleep_title (455088457232472047) -->
    <skip />
    <string name="adaptive_sleep_summary_on" msgid="410222811715459549">"Zapnuto / obrazovka se nevypne, když se na ni budete dívat"</string>
    <string name="adaptive_sleep_summary_off" msgid="3099674463517017514">"Vypnuto"</string>
    <string name="adaptive_sleep_description" msgid="3202004081780217465">"Zabrání ve vypnutí obrazovky, když se na ni budete dívat."</string>
    <!-- no translation found for adaptive_sleep_privacy (5335695648960686765) -->
    <skip />
    <string name="night_display_title" msgid="2626451512200357686">"Noční režim"</string>
    <string name="night_display_text" msgid="1837277457033025056">"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="6574111412154833409">"Plán"</string>
    <string name="night_display_auto_mode_never" msgid="2483761922928753400">"Žádný"</string>
    <string name="night_display_auto_mode_custom" msgid="2379394568898721765">"Zapne se ve zvoleném čase"</string>
    <string name="night_display_auto_mode_twilight" msgid="589042813708244059">"Zapne se od soumraku do úsvitu"</string>
    <string name="night_display_start_time_title" msgid="8918016772613689584">"Čas zahájení"</string>
    <string name="night_display_end_time_title" msgid="8286061578083519350">"Čas ukončení"</string>
    <string name="night_display_status_title" msgid="1784041143360286267">"Stav"</string>
    <string name="night_display_temperature_title" msgid="1435292789272017136">"Intenzita"</string>
    <string name="night_display_summary_off" msgid="1792750041697946539">"Vypnuto / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="3583590137322963513">"Nikdy se automaticky nezapne"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6365668239253173208">"Zapne se automaticky v <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3596291693781757392">"Zapne se automaticky za soumraku"</string>
    <string name="night_display_summary_on" msgid="1355713529996456744">"Zapnuto / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="9117830821363119835">"Nikdy se automaticky nevypne"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="5510753572245577263">"Vypne se automaticky v <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="852270120144683507">"Vypne se automaticky za úsvitu"</string>
    <string name="night_display_activation_on_manual" msgid="277343561277625826">"Zapnout"</string>
    <string name="night_display_activation_off_manual" msgid="4074557720918572883">"Vypnout"</string>
    <string name="night_display_activation_on_twilight" msgid="6976051971534953845">"Zapnout do rána"</string>
    <string name="night_display_activation_off_twilight" msgid="7196227685059907233">"Vypnout do večera"</string>
    <string name="night_display_activation_on_custom" msgid="5472029024427933598">"Zapnout do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="6169984658293744715">"Vypnout do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_not_currently_on" msgid="6273540991113206401">"Noční režim teď není zapnutý"</string>
    <string name="screen_timeout" msgid="4882669461447531301">"Interval vypnutí obrazovky"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"Vypnutí obrazovky"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Doba nečinnosti: <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g>"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Tapeta"</string>
    <string name="style_and_wallpaper_settings_title" msgid="3608097576881470764">"Styly a tapety"</string>
    <string name="wallpaper_settings_summary_default" msgid="3395741565658711416">"Výchozí"</string>
    <string name="wallpaper_settings_summary_custom" msgid="515035303981687172">"Vlastní"</string>
    <string name="wallpaper_suggestion_title" msgid="8583988696513822528">"Změňte si tapetu"</string>
    <string name="wallpaper_suggestion_summary" msgid="1579144009898110491">"Přizpůsobte si obrazovku"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Vybrat tapetu"</string>
    <string name="screensaver_settings_title" msgid="1770575686476851778">"Spořič obrazovky"</string>
    <string name="screensaver_settings_summary_either_long" msgid="7302740999250873332">"Při nabíjení nebo v doku"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"V obou případech"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Při nabíjení"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Při vložení do doku"</string>
    <string name="screensaver_settings_summary_never" msgid="5165622985174349585">"Nikdy"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Vyp."</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1239088321034437608">"Chcete-li nastavit, co se stane, když je telefon vložen do doku nebo je v režimu spánku, zapněte spořič obrazovky."</string>
    <string name="screensaver_settings_when_to_dream" msgid="7262410541382890146">"Kdy spustit"</string>
    <string name="screensaver_settings_current" msgid="4663846038247130023">"Aktuální spořič obrazovky"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Spustit"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Nastavení"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Automatický jas"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Probudit zvednutím zařízení"</string>
    <string name="ambient_display_screen_title" msgid="4252755516328775766">"Ambientní displej"</string>
    <string name="ambient_display_category_triggers" msgid="4359289754456268573">"Kdy zobrazit"</string>
    <string name="doze_title" msgid="2375510714460456687">"Nová oznámení"</string>
    <string name="doze_summary" msgid="3846219936142814032">"Probudit obrazovku, když dostanete oznámení"</string>
    <string name="doze_always_on_title" msgid="1046222370442629646">"Vždy zapnuto"</string>
    <string name="doze_always_on_summary" msgid="6978257596231155345">"Zobrazovat čas, ikony oznámení a další informace. Zvýšené využití baterie."</string>
    <string name="title_font_size" msgid="4405544325522105222">"Velikost písma"</string>
    <string name="short_summary_font_size" msgid="6819778801232989076">"Umožňuje zvětšit nebo zmenšit text"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Nastavení zámku SIM"</string>
    <string name="sim_lock_settings_category" msgid="6242052161214271091">"Zámek SIM karty"</string>
    <string name="sim_lock_settings_summary_off" msgid="8028944267104896401">"Vypnuto"</string>
    <string name="sim_lock_settings_summary_on" msgid="39103355956342985">"Uzamčeno"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Zámek SIM karty"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Zamykat SIM kartu"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"K použití tabletu je vyžadován kód PIN"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"K použití telefonu je vyžadován PIN"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"K použití tabletu je vyžadován kód PIN"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"K použití telefonu je vyžadován PIN"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Změnit PIN SIM karty"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"Kód PIN SIM karty"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Zamykat SIM kartu"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Odemknout SIM kartu"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Starý PIN SIM karty"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Nový PIN SIM karty"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Potvrďte nový kód PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"Kód PIN SIM karty"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Nesprávný kód PIN"</string>
    <string name="sim_pins_dont_match" msgid="1695021563878890574">"Kódy PIN nejsou shodné"</string>
    <string name="sim_change_failed" msgid="3602072380172511475">"Kód PIN nelze změnit.\nMožná jste zadali nesprávný kód PIN."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"PIN SIM karty byl úspěšně změněn."</string>
    <string name="sim_lock_failed" msgid="2489611099235575984">"Stav zámku SIM karty nelze změnit.\nZřejmě jste zadali nesprávný kód PIN."</string>
    <string name="sim_pin_disable_failed" msgid="7932981135799678220">"PIN nelze deaktivovat."</string>
    <string name="sim_pin_enable_failed" msgid="3414621075632931753">"PIN nelze aktivovat."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"OK"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Zrušit"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"Bylo nalezeno několik SIM karet"</string>
    <string name="sim_multi_sims_summary" msgid="2698176447067691396">"Zvolte SIM kartu preferovanou pro mobilní data."</string>
    <string name="sim_change_data_title" msgid="5045967581557404143">"Používat pro mobilní data <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="sim_change_data_message" msgid="4307243848083368600">"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="7929746101841679535">"Použít <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="5567909634636045268">"Změnit preferovanou SIM kartu?"</string>
    <string name="sim_preferred_message" msgid="8466930554330635780">"<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="wrong_pin_code_pukked" msgid="4003655226832658066">"Zadali jste nesprávný kód PIN SIM karty. Nyní musíte za účelem odemknutí zařízení kontaktovat svého operátora."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="1582398808893048097">
      <item quantity="few">Zadali jste nesprávný kód PIN SIM karty. Máte ještě <xliff:g id="NUMBER_1">%d</xliff:g> pokusy.</item>
      <item quantity="many">Zadali jste nesprávný kód PIN SIM karty. Máte ještě <xliff:g id="NUMBER_1">%d</xliff:g> pokusu.</item>
      <item quantity="other">Zadali jste nesprávný kód PIN SIM karty. Máte ještě <xliff:g id="NUMBER_1">%d</xliff:g> pokusů.</item>
      <item quantity="one">Zadali jste nesprávný PIN SIM karty. Zbývá <xliff:g id="NUMBER_0">%d</xliff:g> pokus, poté bude muset zařízení odemknout operátor.</item>
    </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Operace pomocí kódu PIN SIM karty se nezdařila!"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Aktualizace systému"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Verze systému Android"</string>
    <string name="security_patch" msgid="8438384045870296634">"Úroveň opravy zabezpečení Android"</string>
    <string name="model_info" msgid="1952009518045740889">"Model"</string>
    <string name="model_summary" msgid="8306235877567782987">"Model: %1$s"</string>
    <string name="hardware_info" msgid="2605080746512527805">"Model a hardware"</string>
    <string name="hardware_revision" msgid="8893547686367095527">"Verze hardwaru"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"ID zařízení"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Verze základního pásma"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Verze jádra"</string>
    <string name="build_number" msgid="3075795840572241758">"Číslo sestavení"</string>
    <string name="module_version" msgid="4826567303427436423">"Verze hlavního modulu"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Nedostupné"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Stav"</string>
    <string name="device_status" msgid="607405385799807324">"Stav"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Stav baterie, sítě a další údaje"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Telefonní číslo, signál atd."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Úložiště"</string>
    <string name="storage_settings_for_app" msgid="1922207623125501014">"Úložiště a mezipaměť"</string>
    <string name="storage_usb_settings" msgid="7293054033137078060">"Úložiště"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Nastavení úložiště"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Odpojení úložiště USB a zobrazení dostupného úložiště"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Umožňuje odpojit kartu SD a zobrazit dostupnou paměť"</string>
    <string name="imei_multi_sim" msgid="6387012961838800539">"IMEI (slot na SIM kartu %1$d)"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5948892105546651296">"Telefonní číslo"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="2755592991367858860">"MDN (slot na SIM kartu %1$d)"</string>
    <string name="status_number_sim_slot" product="default" msgid="1898212200138025729">"Telefonní číslo (slot na SIM kartu %1$d)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="1367110147304523864">"MDN na SIM kartě"</string>
    <string name="status_number_sim_status" product="default" msgid="9123351360569466330">"Telefonní číslo na SIM kartě"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MIN"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"Verze PRL"</string>
    <string name="meid_multi_sim" msgid="748999971744491771">"MEID (slot na SIM kartu %1$d)"</string>
    <string name="scanning_status_text_wifi_on_ble_on" msgid="5262263689045962681">"Vyhledávání Wi‑Fi a Bluetooth jsou zapnuta"</string>
    <string name="scanning_status_text_wifi_on_ble_off" msgid="2115399719199757550">"Vyhledávání Wi-Fi je zapnuté, vyhledávání Bluetooth je vypnuté"</string>
    <string name="scanning_status_text_wifi_off_ble_on" msgid="3212656150021004088">"Vyhledávání Bluetooth je zapnuté, vyhledávání Wi-Fi je vypnuté"</string>
    <string name="scanning_status_text_wifi_off_ble_off" msgid="6381094990708345188">"Vyhledávání Wi‑Fi a Bluetooth jsou vypnuta"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_data_network_type" msgid="7570837037428932780">"Typ mobilní datové sítě"</string>
    <string name="status_voice_network_type" msgid="5663112239742353547">"Typ mobilní hlasové sítě"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Informace operátora"</string>
    <string name="status_data_state" msgid="5503181397066522950">"Stav mobilní sítě"</string>
    <string name="status_esim_id" msgid="6456255368300906317">"EID"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Stav služby"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Síla signálu"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Roaming"</string>
    <string name="status_operator" msgid="2274875196954742087">"Síť"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"Adresa MAC sítě Wi-Fi"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Adresa Bluetooth"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Sériové číslo"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Doba provozu"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Doba provozu"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Interní úložiště"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"Úložiště USB"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"Karta SD"</string>
    <string name="memory_available" msgid="5052397223077021181">"K dispozici"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"K dispozici (pouze pro čtení)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Celková paměť"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Výpočet…"</string>
    <string name="memory_apps_usage" msgid="5128673488173839077">"Aplikace a data aplikací"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Média"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Stahování"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Fotografie, videa"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Zvuk (hudba, podcasty atd.)"</string>
    <string name="memory_media_misc_usage" msgid="6094866738586451683">"Jiné soubory"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Data uložená v mezipaměti"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Odpojit sdílené úložiště"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Odpojit kartu SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Odpojit interní úložiště USB"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"K bezpečnému odebrání karty SD je potřeba kartu nejprve odpojit"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Vložte úložiště USB"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Vložte kartu SD, kterou chcete připojit."</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Připojit úložiště USB"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Připojit kartu SD"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Smazat úložiště USB"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Smazat kartu SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Smaže všechna data v interním úložišti USB, například hudbu a fotografie"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Smaže všechna data na kartě SD, například hudbu nebo fotografie"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Vymazat data uložená v mezipaměti?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Tímto vymažete z mezipaměti data všech aplikací."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"Funkce MTP nebo PTP je aktivní"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Odpojit úložiště USB?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Odpojit kartu SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Pokud úložiště USB odpojíte, některé používané aplikace přestanou fungovat. Tyto aplikace pravděpodobně nebudou k dispozici, dokud úložiště USB znovu nepřipojíte."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Pokud odpojíte kartu SD, dojde k zastavení některých používaných aplikací. Tyto aplikace pravděpodobně nebudou k dispozici až do opětovného připojení karty SD."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="9191518889746166147">"Úložiště USB nelze odpojit. Zkuste to znovu později."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3500976899159848422">"Kartu SD nelze odpojit. Zkuste to znovu později."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"Úložiště USB bude odpojeno."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"Karta SD bude odpojena."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Odpojování"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Probíhá odpojování"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"V úložišti je málo místa"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Některé systémové funkce, jako například synchronizace, nemusejí fungovat správně. Zkuste uvolnit místo smazáním nebo uvolněním položek, jako jsou aplikace nebo multimediální obsah."</string>
    <string name="storage_menu_rename" msgid="7141058657592615390">"Přejmenovat"</string>
    <string name="storage_menu_mount" msgid="1014683672493425425">"Připojit"</string>
    <string name="storage_menu_unmount" msgid="681485356885955898">"Odpojit"</string>
    <string name="storage_menu_format" msgid="7690626079653152152">"Formátovat"</string>
    <string name="storage_menu_format_public" msgid="7464714208010125682">"Formátovat jako přenosné"</string>
    <string name="storage_menu_format_private" msgid="546017531835902096">"Formátovat jako interní"</string>
    <string name="storage_menu_migrate" msgid="3969621494238154294">"Migrovat data"</string>
    <string name="storage_menu_forget" msgid="6305824238997983426">"Zapomenout"</string>
    <string name="storage_menu_set_up" msgid="4263294929451685366">"Nastavit"</string>
    <string name="storage_menu_explore" msgid="4637496051816521560">"Prozkoumat"</string>
    <string name="storage_menu_free" msgid="6386070442027135427">"Uvolnit místo"</string>
    <string name="storage_menu_manage" msgid="5914482953856430780">"Spravovat úložiště"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Připojení USB k počítači"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Připojit jako"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Zařízení pro média (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Umožňuje přenášet multimediální soubory v systému Windows nebo pomocí aplikace Android File Transfer v systému Mac (další informace na stránce www.android.com/filetransfer)."</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Fotoaparát (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7406889433172511530">"Umožňuje přenos fotografií pomocí softwaru fotoaparátu a přenos jakýchkoli souborů do počítačů, které nepodporují protokol MTP"</string>
    <string name="usb_midi_title" msgid="3069990264258413994">"MIDI"</string>
    <string name="usb_midi_summary" msgid="539169474810956358">"Umožňuje aplikacím s podporou formátu MIDI spolupracovat se softwarem ke zpracování souborů MIDI prostřednictvím USB."</string>
    <string name="storage_other_users" msgid="808708845102611856">"Další uživatelé"</string>
    <string name="storage_internal_title" msgid="690771193137801021">"Úložiště zařízení"</string>
    <string name="storage_external_title" msgid="3433462910096848696">"Přenosné úložiště"</string>
    <string name="storage_volume_summary" msgid="7023441974367853372">"Použito <xliff:g id="USED">%1$s</xliff:g> z <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="storage_size_large" msgid="5691585991420946254">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_volume_used" msgid="1303803057698959872">"Použito z <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_volume_used_total" msgid="6113121714019000244">"Použito celkem z <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_mount_success" msgid="687641090137253647">"Úložiště <xliff:g id="NAME">%1$s</xliff:g> je připojeno"</string>
    <string name="storage_mount_failure" msgid="1042621107954547316">"Připojení úložiště <xliff:g id="NAME">%1$s</xliff:g> se nezdařilo"</string>
    <string name="storage_unmount_success" msgid="5737203344673441677">"Úložiště <xliff:g id="NAME">%1$s</xliff:g> bylo bezpečně odpojeno"</string>
    <string name="storage_unmount_failure" msgid="5758387106579519489">"Úložiště <xliff:g id="NAME">%1$s</xliff:g> nebylo možné bezpečně odpojit"</string>
    <string name="storage_format_success" msgid="3023144070597190555">"Úložiště <xliff:g id="NAME">%1$s</xliff:g> je naformátováno"</string>
    <string name="storage_format_failure" msgid="6032640952779735766">"Formátování úložiště <xliff:g id="NAME">%1$s</xliff:g> se nezdařilo"</string>
    <string name="storage_rename_title" msgid="8242663969839491485">"Přejmenovat úložiště"</string>
    <string name="storage_dialog_unmounted" msgid="6403320870103261477">"Toto úložiště <xliff:g id="NAME_0">^1</xliff:g> bylo bezpečně odpojeno, ale je stále k dispozici. \n\nChcete-li toto úložiště <xliff:g id="NAME_1">^1</xliff:g> použít, musíte jej nejdříve připojit."</string>
    <string name="storage_dialog_unmountable" msgid="3732209361668282254">"Toto úložiště <xliff:g id="NAME_0">^1</xliff:g> je poškozeno. \n\nChcete-li toto úložiště <xliff:g id="NAME_1">^1</xliff:g> použít, musíte jej nejdříve nastavit."</string>
    <string name="storage_dialog_unsupported" msgid="4503128224360482228">"Úložiště <xliff:g id="NAME_0">^1</xliff:g> není v tomto zařízení podporováno. \n\nChcete-li toto úložiště <xliff:g id="NAME_1">^1</xliff:g> použít s tímto zařízením, musíte jej nejdříve nastavit."</string>
    <string name="storage_internal_format_details" msgid="4018647158382548820">"Po naformátování budete moci toto úložiště <xliff:g id="NAME_0">^1</xliff:g> používat s jinými zařízeními. \n\nVeškerá data v tomto úložišti <xliff:g id="NAME_1">^1</xliff:g> budou vymazána. Doporučujeme je nejprve zálohovat. \n\n"<b>"Zálohování fotek a jiných medií"</b>" \nMediální soubory přesuňte do jiného úložiště v zařízení nebo je pomocí kabelu USB přeneste do počítače. \n\n"<b>"Zálohování aplikací"</b>" \nVšechny aplikace uložené v tomto úložišti <xliff:g id="NAME_6">^1</xliff:g> budou odinstalovány a jejich data budou vymazána. Chcete-li tyto aplikace zachovat, přesuňte je do jiného úložiště v zařízení."</string>
    <string name="storage_internal_unmount_details" msgid="3582802571684490057"><b>"Když toto úložiště <xliff:g id="NAME_0">^1</xliff:g> odpojíte, aplikace, kterou jsou v něm uloženy, přestanou fungovat a mediální soubory nebudou dostupné, dokud jej opět nevložíte."</b>\n\n"Toto úložiště <xliff:g id="NAME_1">^1</xliff:g> je naformátováno tak, aby fungovalo pouze v tomto zařízení. V jiných zařízeních fungovat nebude."</string>
    <string name="storage_internal_forget_details" msgid="9028875424669047327">"Chcete-li použít aplikace, fotky nebo data, která jsou v úložišti <xliff:g id="NAME">^1</xliff:g>, vložte jej znovu.\n\nPokud toto zařízení není k dispozici, můžete alternativně zvolit, že má být zapomenuto.\n\nPokud se rozhodnete zařízení zapomenout, veškerá data v zařízení budou navždy ztracena.\n\nAplikace můžete znovu nainstalovat později. Jejich data uložená v tomto zařízení však budou ztracena."</string>
    <string name="storage_internal_forget_confirm_title" msgid="1370847944388479245">"Zapomenout úložiště <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="1148446041396902905">"Všechny aplikace, fotky a data uložená v tomto úložišti <xliff:g id="NAME">^1</xliff:g> budou navždy ztracena."</string>
    <string name="storage_detail_apps" msgid="6141154016753507490">"Aplikace"</string>
    <string name="storage_detail_images" msgid="6950678857740634769">"Obrázky"</string>
    <string name="storage_detail_videos" msgid="2919743464827110953">"Videa"</string>
    <string name="storage_detail_audio" msgid="1197685141676483213">"Zvuk"</string>
    <string name="storage_detail_cached" msgid="8547136365247818567">"Data uložená v mezipaměti"</string>
    <string name="storage_detail_other" msgid="8404938385075638238">"Jiné"</string>
    <string name="storage_detail_system" msgid="4629506366064709687">"Systém"</string>
    <string name="storage_detail_explore" msgid="7911344011431568294">"Prozkoumat úložiště <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_detail_dialog_other" msgid="8845766044697204852">"Mezi ostatní soubory patří sdílené soubory uložené aplikacemi, soubory stažené z internetu nebo přes Bluetooth, soubory systému Android apod. \n\nChcete-li zobrazit viditelný obsah tohoto úložiště typu <xliff:g id="NAME">^1</xliff:g>, klepněte na Prozkoumat."</string>
    <string name="storage_detail_dialog_system" msgid="862835644848361569">"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_detail_dialog_user" msgid="3267254783294197804">"Uživatel <xliff:g id="USER_0">^1</xliff:g> může mít uložené fotky, hudbu, aplikace a další data, která využívají <xliff:g id="SIZE">^2</xliff:g> úložiště. \n\nChcete-li zobrazit podrobnosti, přepněte na účet uživatele <xliff:g id="USER_1">^1</xliff:g>."</string>
    <string name="storage_wizard_init_title" msgid="5085400514028585772">"Nastavte úložiště <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="4867326438945303598">"Použít jako přenosné úložiště"</string>
    <string name="storage_wizard_init_external_summary" msgid="7476105886344565074">"K přenášení fotek a dalších médií mezi zařízeními."</string>
    <string name="storage_wizard_init_internal_title" msgid="9100613534261408519">"Použít jako interní úložiště"</string>
    <string name="storage_wizard_init_internal_summary" msgid="6240417501036216410">"K ukládání libovolných dat, včetně aplikací a fotek, pouze do tohoto zařízení. Vyžaduje naformátování, které způsobí, že nebude fungovat v jiných zařízeních."</string>
    <string name="storage_wizard_format_confirm_title" msgid="2814021794538252546">"Formátovat jako interní úložiště"</string>
    <string name="storage_wizard_format_confirm_body" msgid="4401758710076806509">"Proto je nutné úložiště <xliff:g id="NAME_0">^1</xliff:g> zabezpečit pomocí formátování. \n\nPo naformátování bude úložiště <xliff:g id="NAME_1">^1</xliff:g> fungovat pouze v tomto zařízení. \n\n"<b>"Formátováním vymažete veškerá data, která jsou v tomto úložišti <xliff:g id="NAME_2">^1</xliff:g> uložena."</b>" Chcete-li ztrátě dat předejít, doporučujeme je zálohovat."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="4905690038882041566">"Formátovat jako přenosné úložiště"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="1516932692920060272">"Tato akce vyžaduje, aby úložiště <xliff:g id="NAME_0">^1</xliff:g> bylo naformátováno. \n\n"<b>"Formátováním vymažete veškerá data z úložiště <xliff:g id="NAME_1">^1</xliff:g>."</b>" Chcete-li předejít ztrátě dat, doporučujeme je zálohovat."</string>
    <string name="storage_wizard_format_confirm_next" msgid="2774557300531702572">"Vymazat a naformátovat"</string>
    <string name="storage_wizard_format_progress_title" msgid="6487352396450582292">"Formátování úložiště <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="3983764797223576658">"Během formátování médium <xliff:g id="NAME">^1</xliff:g> neodpojujte."</string>
    <string name="storage_wizard_migrate_title" msgid="1363078147938160407">"Přesuňte data do nového úložiště"</string>
    <string name="storage_wizard_migrate_body" msgid="890751699549542345">"Do tohoto nového úložiště <xliff:g id="NAME">^1</xliff:g> můžete přesunout fotky, soubory a některé aplikace. \n\nPřesun bude trvat <xliff:g id="TIME">^2</xliff:g> a v interním úložišti uvolní <xliff:g id="SIZE">^3</xliff:g>. Během přesunu nebudou některé aplikace fungovat."</string>
    <string name="storage_wizard_migrate_now" msgid="4523444323744239143">"Přesunout"</string>
    <string name="storage_wizard_migrate_later" msgid="3173482328116026253">"Přesunout později"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="8564833529613286965">"Přesun dat"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="4212060581792135962"><b>"Doba přesunu: cca <xliff:g id="TIME">^1</xliff:g>. <xliff:g id="NAME">^3</xliff:g> uvolní <xliff:g id="SIZE">^2</xliff:g>."</b></string>
    <string name="storage_wizard_migrate_confirm_next" msgid="5509475628423823202">"Přesunout"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="1665479429044202868">"Probíhá přesun dat…"</string>
    <string name="storage_wizard_migrate_details" msgid="3709728824651136227">"Během přesunu: \n• Neodpojujte <xliff:g id="NAME">^1</xliff:g>. \n• Některé aplikace nebudou fungovat správně. \n• Udržujte zařízení nabité."</string>
    <string name="storage_wizard_ready_title" msgid="6553867088682695655">"Médium <xliff:g id="NAME">^1</xliff:g> se již používá"</string>
    <string name="storage_wizard_ready_external_body" msgid="2879508114260597474">"Nyní do úložiště <xliff:g id="NAME">^1</xliff:g> můžete ukládat fotky a další média."</string>
    <string name="storage_wizard_ready_internal_body" msgid="122532674037860197">"Nové úložiště <xliff:g id="NAME">^1</xliff:g> již funguje. \n\nChcete-li do tohoto zařízení přesunout fotky, soubory a data aplikací, přejděte do Nastavení &gt; Úložiště."</string>
    <string name="storage_wizard_move_confirm_title" msgid="292782012677890250">"Přesuňte aplikaci <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="5176432115206478941">"Přesunutí aplikace <xliff:g id="APP">^1</xliff:g> a jejích dat do úložiště <xliff:g id="NAME_0">^2</xliff:g> bude trvat jen chvíli. Aplikaci bude možné používat až po dokončení přesunu. \n\nÚložiště <xliff:g id="NAME_1">^2</xliff:g> během přesunu neodpojujte."</string>
    <string name="storage_wizard_move_unlock" msgid="1526216561023200694">"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="4443920302548035674">"Probíhá přesun aplikace <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="7802577486578105609">"Úložiště <xliff:g id="NAME">^1</xliff:g> během přesunu nevysouvejte. \n\nAplikace <xliff:g id="APP">^2</xliff:g> bude v tomto zařízení k dispozici až po dokončení přesunu."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="542047237524588792">"Zrušit přesun"</string>
    <string name="storage_wizard_slow_body" msgid="8010127667184768025">"Toto zařízení <xliff:g id="NAME_0">^1</xliff:g> je pravděpodobně pomalé. \n\nMůžete pokračovat, ale aplikace přesunuté do tohoto umístění budou mít prodlevy a přenosy dat mohou trvat delší dobu. \n\nZkuste použít rychlejší zařízení <xliff:g id="NAME_1">^1</xliff:g>, které zajistí vyšší výkon."</string>
    <string name="storage_wizard_init_v2_title" msgid="8858395869710288372">"Jak chcete toto médium <xliff:g id="NAME">^1</xliff:g> používat?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="4315585580670552654">"Dodatečné úložiště tabletu"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="570443086512059390">"Aplikace, soubory a mediální obsah pouze v tomto tabletu"</string>
    <string name="storage_wizard_init_v2_internal_action" product="tablet" msgid="7760758592993284143">"Úložiště tabletu"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="8373070138732653456">"Dodatečné úložiště telefonu"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="685194340141573218">"Aplikace, soubory a mediální obsah pouze v tomto zařízení"</string>
    <string name="storage_wizard_init_v2_internal_action" product="default" msgid="904425171564310150">"Úložiště telefonu"</string>
    <string name="storage_wizard_init_v2_or" msgid="1958295749349454436">"nebo"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="3565348221712759463">"Přenosné úložiště"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="801198071793584445">"Přenos souborů a mediálního obsahu mezi zařízeními"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="8662451480642784031">"Přenosné úložiště"</string>
    <string name="storage_wizard_init_v2_later" msgid="1080613420170749130">"Nastavit později"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="5744790239994621663">"Naformátovat médium <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="4614199613500900975">"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\nFormátováním z média <xliff:g id="NAME_1">^2</xliff:g> odstraníte všechen stávající obsah. Nechcete-li o obsah přijít, zálohujte si ho do jiného média <xliff:g id="NAME_2">^3</xliff:g> nebo do zařízení."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="8258363472135537500">"Formátovat médium <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="31406330052996898">"Přesunout obsah na médium <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4476553430145054781">"Na toto médium <xliff:g id="NAME">^1</xliff:g> můžete přesunout soubory, některé aplikace a další obsah. \n\nPřesunem uvolníte <xliff:g id="SIZE">^2</xliff:g> úložiště tabletu a potrvá to asi <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_body" product="default" msgid="744760728669284385">"Na toto médium <xliff:g id="NAME">^1</xliff:g> můžete přesunout soubory, některé aplikace a další obsah. \n\nPřesunem uvolníte <xliff:g id="SIZE">^2</xliff:g> úložiště telefonu a potrvá to asi <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="1239103359606165360">"Během přesunu:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="7176991995007075843">"Médium <xliff:g id="NAME">^1</xliff:g> neodpojujte"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="3671266712947078734">"Některé aplikace nebudou fungovat"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="346012901366624052">"Tablet nabíjejte"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="3061158350109289521">"Telefon nabíjejte"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="1279041707982039591">"Přesunout obsah"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="8201360307047198853">"Přesunout obsah později"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="1323344099111423785">"Přesun obsahu…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="1318285829973607727">"Pomalé médium <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="6897444467730463117">"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="4126873669723115805">"Začít znovu"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="49399942893518218">"Pokračovat"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="11937346870534608">"Obsah můžete přesunout na médium <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="4658433206901211269">"Chcete-li obsah přesunout na médium <xliff:g id="NAME">^1</xliff:g>, přejděte do "<b>"Nastavení &gt; Úložiště"</b></string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="6239886818487538806">"Obsah byl přesunut na médium <xliff:g id="NAME_0">^1</xliff:g>. \n\nChcete-li médium <xliff:g id="NAME_1">^2</xliff:g> spravovat, přejděte do "<b>"Nastavení &gt; Úložiště"</b>"."</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Stav baterie"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Nabití baterie"</string>
    <string name="apn_settings" msgid="3743170484827528406">"Přístupové body"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Upravit přístupový bod"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Nenastaveno"</string>
    <string name="apn_name" msgid="4115580098369824123">"Název"</string>
    <string name="apn_apn" msgid="2479425126733513353">"Název přístupového bodu"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Proxy"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Port"</string>
    <string name="apn_user" msgid="455637547356117761">"Uživatelské jméno"</string>
    <string name="apn_password" msgid="5412301994998250968">"Heslo"</string>
    <string name="apn_server" msgid="2436185314756372858">"Server"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"Proxy server systému MMS"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"Port systému MMS"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Typ ověření"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Žádné"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP nebo CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Typ přístupového bodu"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"Protokol APN"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protokol APN pro roaming"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Povolit/zakázat APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"Přístupový bod je povolen"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"Přístupový bod je zakázán"</string>
    <string name="bearer" msgid="594270280031923558">"Nositel"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Typ MVNO"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Hodnota MVNO"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Smazat přístupový bod"</string>
    <string name="menu_new" msgid="3014205883303921729">"Nový přístupový bod"</string>
    <string name="menu_save" msgid="8109345640668285399">"Uložit"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Zahodit"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="5508155943840201232">"Pole Jméno nesmí být prázdné."</string>
    <string name="error_apn_empty" msgid="4932211013600863642">"Název přístupového bodu nesmí být prázdný."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"Pole MCC musí obsahovat 3 číslice."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Pole MNC musí obsahovat 2 nebo 3 číslice."</string>
    <string name="error_adding_apn_type" msgid="4181334016628549645">"Operátor přidání přístupových bodů typu %s neumožňuje."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Obnovování výchozích nastavení přístupového bodu"</string>
    <string name="menu_restore" msgid="8260067415075573273">"Obnovit výchozí"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Výchozí nastavení přístupového bodu bylo obnoveno."</string>
    <string name="reset_dashboard_title" msgid="6254873816990678620">"Možnosti resetu"</string>
    <string name="reset_dashboard_summary" msgid="4851012632493522755">"Lze resetovat síť, aplikace nebo zařízení"</string>
    <string name="reset_network_title" msgid="6166025966016873843">"Resetovat Wi-Fi, data a Bluetooth"</string>
    <string name="reset_network_desc" msgid="5547979398298881406">"Budou resetována nastavení všech sítí, včetně následujících:\n\n"<li>"Wi‑Fi"</li>\n<li>"Mobilní data"</li>\n<li>"Bluetooth"</li></string>
    <string name="reset_esim_title" msgid="1979762943163078939">"Vymazat stažení SIM karty"</string>
    <string name="reset_esim_desc" msgid="5940105242448544634">"Chcete-li stáhnout náhradní SIM kartu, kontaktujte operátora. Tímto krokem nebude zrušen mobilní tarif."</string>
    <string name="reset_network_button_text" msgid="2035676527471089853">"Obnovit nastavení"</string>
    <string name="reset_network_final_desc" msgid="4690205209934596665">"Chcete resetovat všechna nastavení sítí? Tuto akci nelze vrátit zpět."</string>
    <string name="reset_network_final_desc_esim" msgid="6641433458865914227">"Obnovit všechna síťová nastavení a vymazat stažené SIM karty? Tuto akci nelze vrátit zpět."</string>
    <string name="reset_network_final_button_text" msgid="1797434793741744635">"Obnovit nastavení"</string>
    <string name="reset_network_confirm_title" msgid="1759888886976962773">"Obnovit nastavení?"</string>
    <string name="network_reset_not_available" msgid="7188610385577164676">"Pro tohoto uživatele resetování sítě není k dispozici"</string>
    <string name="reset_network_complete_toast" msgid="787829973559541880">"Nastavení sítí bylo resetováno"</string>
    <string name="reset_esim_error_title" msgid="2679159494023044398">"SIM karty nelze vymazat"</string>
    <string name="reset_esim_error_msg" msgid="1356899750645220749">"Staženou SIM kartu nelze vymazat z důvodu chyby.\n\nRestartujte zařízení a zkuste to znovu."</string>
    <string name="master_clear_title" msgid="3531267871084279512">"Vymazat data (tovární reset)"</string>
    <string name="master_clear_short_title" msgid="8652450915870274285">"Vymazat data (tovární reset)"</string>
    <string name="master_clear_desc" product="tablet" msgid="2314458161059569301">"Tato akce smaže veškerá data z "<b>"interního úložiště"</b>" tabletu, např.:\n\n"<li>"váš účet Google"</li>\n<li>"nastavení a data systému a aplikací"</li>\n<li>"stažené aplikace"</li></string>
    <string name="master_clear_desc" product="default" msgid="7647628092266675099">"Tato akce smaže veškerá data z "<b>"interního úložiště"</b>" telefonu, např.:\n\n"<li>"váš účet Google"</li>\n<li>"nastavení a data systému a aplikací"</li>\n<li>"stažené aplikace"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Aktuálně jste přihlášeni k těmto účtům:\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="5161423070702470742">\n\n"V tomto zařízení jsou přítomni další uživatelé.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"hudba"</li>\n<li>"fotky"</li>\n<li>"další uživatelské údaje"</li></string>
    <string name="master_clear_desc_also_erases_esim" msgid="6008213558725767177"><li>"eSIM"</li></string>
    <string name="master_clear_desc_no_cancel_mobile_plan" msgid="5460926449093211144">\n\n"Tímto krokem nebude zrušen mobilní tarif."</string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Chcete-li smazat také hudbu, obrázky a další uživatelská data, je potřeba vymazat "<b>"úložiště USB"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Chcete-li smazat také hudbu, obrázky a další uživatelská data, je potřeba vymazat "<b>"kartu SD"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Smazat úložiště USB"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Smazat kartu SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Smazat všechna data v interním úložišti USB, například hudbu a fotografie."</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Smazat všechna data na kartě SD, například hudbu a fotografie."</string>
    <string name="master_clear_button_text" product="tablet" msgid="1893179883931194922">"Vymazat všechna data"</string>
    <string name="master_clear_button_text" product="default" msgid="1893179883931194922">"Vymazat všechna data"</string>
    <string name="master_clear_final_desc" msgid="8219087639717327355">"Všechny osobní údaje a stažené aplikace budou smazány. Tuto akci nelze vrátit zpět."</string>
    <string name="master_clear_final_desc_esim" msgid="4580223096319568030">"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="master_clear_final_button_text" msgid="5390908019019242910">"Vymazat vše"</string>
    <string name="master_clear_failed" msgid="2503230016394586353">"Pokus o obnovení se nezdařil, protože služba System Clear není dostupná."</string>
    <string name="master_clear_confirm_title" msgid="1134724452049918413">"Vymazat všechna data?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Pro tohoto uživatele není obnovení továrního nastavení dostupné"</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Mazání"</string>
    <string name="master_clear_progress_text" msgid="6559096229480527510">"Prosím čekejte..."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Nastavení hovorů"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Nastavení hlasové schránky, přesměrování a čekání hovorů a ID volajícího"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Připojení přes USB"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Přenosný hotspot"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Připojení přes Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Sdílené připojení"</string>
    <string name="tether_settings_title_all" msgid="3058586928118801157">"Hotspot a tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="930464462687425777">"Hotspot je zapnutý, datové připojení se sdílí"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="3473671453891735907">"Hotspot je zapnutý"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="1618256180720077354">"Sdílení datového připojení"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="1576908608463904152">"Když je zapnutý Spořič obrazovky, nelze sdílet datové připojení ani používat přenosné hotspoty"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Připojení přes USB"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3711893746716442706">"Sdílet připojení telefonu k internetu přes USB"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="2292916486612255069">"Sdílet připojení tabletu k internetu přes USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Připojení přes Bluetooth"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="8828883800511737077">"Sdílet připojení tabletu k internetu přes Bluetooth"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="1904667146601254812">"Sdílet připojení telefonu k internetu přes Bluetooth"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="376389105752995580">"Internetové připojení tohoto zařízení <xliff:g id="DEVICE_NAME">%1$d</xliff:g> je sdíleno přes Bluetooth"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="2135590598511178690">"Připojení lze sdílet s nejvýše <xliff:g id="MAXCONNECTION">%1$d</xliff:g> zařízeními."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"U zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bude ukončeno sdílené připojení."</string>
    <string name="tethering_footer_info" msgid="7112228674056306147">"Hotspot a tethering umožňují poskytovat připojení k internetu přes mobilní datové připojení dalším zařízením. Aplikace také mohou vytvořit hotspot ke sdílení obsahu s okolními zařízeními."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Nápověda"</string>
    <string name="network_settings_title" msgid="2876509814832830757">"Mobilní síť"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Mobilní tarif"</string>
    <string name="sms_application_title" msgid="4903928270533250448">"Aplikace pro SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Chcete změnit aplikaci SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Chcete pro zprávy SMS používat aplikaci <xliff:g id="NEW_APP">%1$s</xliff:g> místo aplikace <xliff:g id="CURRENT_APP">%2$s</xliff:g>?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Chcete pro zprávy SMS používat aplikaci <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="network_scorer_picker_title" msgid="6383879578279046456">"Poskytovatel hodnocení sítí"</string>
    <string name="network_scorer_picker_none_preference" msgid="9028375117241790936">"Žádné"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"Změnit nastavení Google Wi-Fi Assistant?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"Chcete spravovat síťová připojení pomocí aplikace <xliff:g id="NEW_APP">%1$s</xliff:g> namísto aplikace <xliff:g id="CURRENT_APP">%2$s</xliff:g>?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="7444620909047611601">"Chcete spravovat síťová připojení pomocí aplikace <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Operátor SIM karty není znám"</string>
    <string name="mobile_no_provisioning_url" msgid="9053814051811634125">"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="9052590985784056395">"Vložte SIM kartu a restartujte zařízení."</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Připojte se prosím k internetu."</string>
    <string name="location_title" msgid="1029961368397484576">"Moje poloha"</string>
    <string name="managed_profile_location_switch_title" msgid="6712332547063039683">"Umístění pracovního profilu"</string>
    <string name="location_app_level_permissions" msgid="2777033567595680764">"Oprávnění aplikací"</string>
    <string name="location_app_permission_summary_location_off" msgid="2790918244874943070">"Je vypnuté určování polohy."</string>
    <plurals name="location_app_permission_summary_location_on" formatted="false" msgid="6755614454444493071">
      <item quantity="few"><xliff:g id="BACKGROUND_LOCATION_APP_COUNT_2">%1$d</xliff:g> ze <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g> aplikací má neomezený přístup</item>
      <item quantity="many"><xliff:g id="BACKGROUND_LOCATION_APP_COUNT_2">%1$d</xliff:g> z <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g> aplikace má neomezený přístup</item>
      <item quantity="other"><xliff:g id="BACKGROUND_LOCATION_APP_COUNT_2">%1$d</xliff:g> z <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g> aplikací má neomezený přístup</item>
      <item quantity="one"> <xliff:g id="BACKGROUND_LOCATION_APP_COUNT_0">%1$d</xliff:g> z <xliff:g id="TOTAL_LOCATION_APP_COUNT_1">%2$d</xliff:g> aplikace má neomezený přístup</item>
    </plurals>
    <string name="location_category_recent_location_access" msgid="4911449278675337490">"Nedávný přístup k poloze"</string>
    <string name="location_recent_location_access_view_details" msgid="1955078513330927035">"Zobrazit podrobnosti"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"V poslední době žádné aplikace o polohu nepožádaly."</string>
    <string name="location_no_recent_accesses" msgid="7489449862187886009">"Polohu v poslední době nepoužily žádné aplikace"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Vysoké využívání baterie"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Nízké využívání baterie"</string>
    <string name="location_scanning_screen_title" msgid="2297479353298444503">"Vyhledávání přes Wi-Fi a Bluetooth"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="6216705505621183645">"Vyhledávání Wi‑Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="2691110218127379249">"Povolit 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="5444989508204520019">"Vyhledávání Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="1285526059945206128">"Povolit aplikacím a službám vyhledávat zařízení v okolí kdykoliv, 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="managed_profile_location_services" msgid="4723268446874715222">"Služby určování polohy pro práci"</string>
    <string name="location_network_based" msgid="9134175479520582215">"Poloha Wi-Fi a mobilní sítě"</string>
    <string name="location_neighborhood_level" msgid="5141318121229984788">"Povolit aplikacím používat službu určování polohy Google a rychleji odhadovat vaši polohu. Anonymní data budou sbírána a odesílána Googlu."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Poloha určená sítí Wi-Fi"</string>
    <string name="location_gps" msgid="8392461023569708478">"Satelity GPS"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Povolit aplikacím ve vašem tabletu určovat polohu pomocí GPS"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Povolit aplikacím ve vašem telefonu určovat polohu pomocí GPS"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Použít systém A-GPS"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Vylepšit funkčnost GPS pomocí serveru (deaktivací této funkce snížíte využití sítě)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Vylepšit funkčnost GPS pomocí serveru (zrušením této funkce zvýšíte výkon GPS)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Poloha a vyhledávání"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Povolit Googlu použít vaši polohu ke zlepšení výsledků vyhledávání a dalších služeb"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Přístup k údajům o mé poloze"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Povolit aplikacím, které o to požádaly, používat údaje o poloze"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Zdroje polohy"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"Informace o tabletu"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"Informace o telefonu"</string>
    <string name="about_settings" product="device" msgid="6717640957897546887">"Informace o zařízení"</string>
    <string name="about_settings" product="emulator" msgid="221313099578564438">"Informace o emulovaném zařízení"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Zobrazí právní informace, stav a verzi softwaru"</string>
    <string name="legal_information" msgid="5769301644270604095">"Právní informace"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Přispěvatelé"</string>
    <string name="manual" msgid="3025943393642974445">"Příručka"</string>
    <string name="regulatory_labels" msgid="1293050314122427492">"Regulační štítky"</string>
    <string name="safety_and_regulatory_info" msgid="5103161279848427185">"Příručka k bezpečnosti a předpisům"</string>
    <string name="copyright_title" msgid="865906688917260647">"Autorská práva"</string>
    <string name="license_title" msgid="1990487604356037871">"Licence"</string>
    <string name="terms_title" msgid="7697580845616764642">"Smluvní podmínky"</string>
    <string name="webview_license_title" msgid="2813507464175738967">"Systémová licence WebView"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Tapety"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Poskytovatelé satelitních snímků:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="8133150693616006051">"Příručka"</string>
    <string name="settings_manual_activity_unavailable" msgid="4752403782883814898">"Při načítání příručky došlo k chybě."</string>
    <string name="settings_license_activity_title" msgid="8525014571806471216">"Licence třetích stran"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Při načítání licencí došlo k chybě."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Načítání..."</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Bezpečnostní informace"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Bezpečnostní informace"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="142307697309858185">"Datové připojení momentálně není k dispozici. Chcete-li tyto informace zobrazit, přejděte z libovolného počítače připojeného k internetu na stránku %s."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Načítání..."</string>
    <string name="confirm_device_credential_use_alternate_method" msgid="793877757665026949">"Použít alternativní metodu"</string>
    <string name="lockpassword_choose_your_screen_lock_header" msgid="2942199737559900752">"Nastavení zámku obrazovky"</string>
    <string name="lockpassword_choose_your_password_message" msgid="5377842480961577542">"Z bezpečnostních důvodů nastavte heslo"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="6624409510609085450">"Otisk vyžaduje nastavení hesla"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="5901096361617543819">"Otisk vyžaduje nastavení gesta"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="6658264750811929338">"Z bezpečnostních důvodů nastavte PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="765344692615917183">"Otisk vyžaduje nastavení PINu"</string>
    <string name="lockpassword_choose_your_pattern_message" msgid="8631545254345759087">"Z bezpečnostních důvodů nastavte gesto"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="1266027268220850931">"Znovu zadejte heslo"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Potvrďte své gesto"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="7744513791910572550">"Znovu zadejte PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="5140892109439191415">"Hesla nejsou shodná"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="7226244811505606217">"Kódy PIN nejsou shodné"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="2872194349688886781">"Znovu zadejte gesto"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Výběr odemknutí"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Heslo bylo nastaveno"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"Kód PIN byl nastaven"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Gesto bylo nastaveno"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="7876621019688907534">"Nastavte heslo pro ověření obličejem"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="8070525076987585344">"Nastavte gesto pro ověření obličejem"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="7304398683609714816">"Nastavte PIN pro ověření obličejem"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="2920960858283879113">"Chcete-li pokračovat, zadejte gesto zařízení."</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="4062335874438910487">"Chcete-li pokračovat, zadejte PIN zařízení."</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="3976394862548354966">"Chcete-li pokračovat, zadejte heslo zařízení."</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="4435638308193361861">"Chcete-li pokračovat, zadejte pracovní gesto."</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="3730141667547002246">"Chcete-li pokračovat, zadejte pracovní PIN."</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="4250642723467019894">"Chcete-li pokračovat, zadejte pracovní heslo."</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="530802132223800623">"Za účelem zvýšení zabezpečení použijte gesto zařízení"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="7829294830078036417">"Za účelem zvýšení zabezpečení zadejte PIN zařízení"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="3552644641574796973">"Za účelem zvýšení zabezpečení zadejte heslo zařízení"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="3003781907040522053">"Za účelem zvýšení zabezpečení použijte pracovní gesto"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="3367491332598821552">"Za účelem zvýšení zabezpečení zadejte pracovní PIN"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="8159775129968582940">"Za účelem zvýšení zabezpečení zadejte pracovní heslo"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6757336656791723193">"Telefon byl obnoven do továrního nastavení. Chcete-li tento telefon použít, zadejte předchozí gesto."</string>
    <string name="lockpassword_confirm_your_pin_details_frp" msgid="826520613445990470">"Telefon byl obnoven do továrního nastavení. Chcete-li tento telefon použít, zadejte předchozí PIN."</string>
    <string name="lockpassword_confirm_your_password_details_frp" msgid="8944081074615739040">"Telefon byl obnoven do továrního nastavení. Chcete-li tento telefon použít, zadejte předchozí heslo."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="2898036091609128286">"Ověřte gesto"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="4141601774778898803">"Ověřte PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="3762615419295360480">"Ověřte heslo"</string>
    <string name="lockpassword_invalid_pin" msgid="15588049067548470">"Nesprávný kód PIN"</string>
    <string name="lockpassword_invalid_password" msgid="4038507398784975200">"Nesprávné heslo"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="1745247595356012176">"Nesprávné gesto"</string>
    <string name="lock_settings_title" msgid="4213839087748988686">"Zabezpečení zařízení"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Změna bezpečnostního gesta"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Změna bezpečnostního kódu PIN"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Proveďte odemykací gesto"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Nápovědu zobrazíte stisknutím klávesy Menu."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Na závěr zvedněte prst z obrazovky"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Spojte alespoň <xliff:g id="NUMBER">%d</xliff:g> tečky. Zkuste to znovu."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Gesto bylo zaznamenáno"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Potvrďte své gesto"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Nové bezpečnostní gesto"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Potvrdit"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Nakreslit znovu"</string>
    <string name="lockpattern_retry_button_text" msgid="3480423193273588166">"Vymazat"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Pokračovat"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Gesto odemknutí"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Požadovat gesto"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Obrazovku je třeba odemknout gestem ruky."</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Zobrazovat gesto"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="4864525074768391381">"Zobrazit gesto profilu"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="4389015658335522989">"Vibrovat při klepnutí"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Vypínač zamkne zařízení"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"Pokud odemknutí není udržováno funkcí <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Nastavení bezpečnostního gesta"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Změna bezpečnostního gesta"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Gesto odemknutí obrazovky proveďte tímto způsobem"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="6909161623701848863">"Příliš mnoho neplatných pokusů. Zkuste to znovu za <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Aplikace není v telefonu nainstalována."</string>
    <string name="lock_settings_profile_title" msgid="2121876391814535295">"Zabezpečení pracovního profilu"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3334747927367115256">"Zámek obrazovky pracovního profilu"</string>
    <string name="lock_settings_profile_unification_title" msgid="4973102698492659123">"Používat jeden zámek"</string>
    <string name="lock_settings_profile_unification_summary" msgid="7178299172998641303">"Používat pro pracovní profil a obrazovku zařízení jeden zámek"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="4824620230229285301">"Používat jeden zámek?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="7128305504872026659">"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="3221303098797469900">"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="8249970828159656518">"Používat jeden zámek"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="5943758576756482777">"Používat jeden zámek"</string>
    <string name="lock_settings_profile_unified_summary" msgid="9008819078132993492">"Stejný jako zámek obrazovky zařízení"</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Spravovat aplikace"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Umožňuje spravovat a odebírat instalované aplikace"</string>
    <string name="applications_settings" msgid="5281808652705396152">"O aplikaci"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Správa aplikací a klávesových zkratek rychlého spuštění"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Nastavení aplikace"</string>
    <string name="install_applications" msgid="4872012136210802181">"Neznámé zdroje"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Povolit všechny zdroje aplikací"</string>
    <string name="recent_app_category_title" msgid="6673071268966003928">"Nedávno otevřené aplikace"</string>
    <string name="see_all_apps_title" msgid="1317153498074308438">"Zobrazit všechny aplikace (<xliff:g id="COUNT">%1$d</xliff:g>)"</string>
    <string name="install_all_warning" product="tablet" msgid="8310489909586138165">"Tablet a osobní údaje jsou zranitelnější vůči útoku ze strany neznámých aplikací. Instalací aplikací z tohoto zdroje vyjadřujete souhlas s tím, že nesete odpovědnost za případné poškození tabletu nebo ztrátu dat, které jejich používání může způsobit."</string>
    <string name="install_all_warning" product="default" msgid="1952257127370115988">"Telefon a osobní údaje jsou zranitelnější vůči útoku ze strany neznámých aplikací. Instalací aplikací z tohoto zdroje vyjadřujete souhlas s tím, že nesete odpovědnost za případné poškození telefonu nebo ztrátu dat, které jejich používání může způsobit."</string>
    <string name="install_all_warning" product="device" msgid="3648003301476423145">"Zařízení a osobní údaje jsou zranitelnější vůči útoku ze strany neznámých aplikací. Instalací aplikací z tohoto zdroje vyjadřujete souhlas s tím, že nesete odpovědnost za případné poškození zařízení nebo ztrátu dat, které jejich používání může způsobit."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Upřesnit nastavení"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Povolit další možnosti nastavení"</string>
    <string name="application_info_label" msgid="5736524913065714880">"O aplikaci"</string>
    <string name="storage_label" msgid="8700867073480107253">"Úložiště"</string>
    <string name="auto_launch_label" msgid="2669236885531442195">"Otevírat ve výchozím nastavení"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Výchozí aplikace"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Kompatibilita s obrazovkou"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Oprávnění"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Mezipaměť"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Vymazat mezipaměť"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Mezipaměť"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="3983110543017963732">
      <item quantity="few">%d položky</item>
      <item quantity="many">%d položky</item>
      <item quantity="other">%d položek</item>
      <item quantity="one">1 položka</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="8575655132961012158">"Zrušit přístup"</string>
    <string name="controls_label" msgid="7611113077086853799">"Ovládací prvky"</string>
    <string name="force_stop" msgid="7435006169872876756">"Vynutit ukončení"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Celkem"</string>
    <string name="application_size_label" msgid="7376689739076506885">"Velikost aplikace"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Aplikace úložiště USB"</string>
    <string name="data_size_label" msgid="6117971066063850416">"Uživatelská data"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Data úložiště USB"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"Karta SD"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Odinstalovat"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Odinstalovat pro všechny uživatele"</string>
    <string name="install_text" msgid="884360662922471113">"Instalovat"</string>
    <string name="disable_text" msgid="6544054052049395202">"Deaktivovat"</string>
    <string name="enable_text" msgid="9217362512327828987">"Aktivovat"</string>
    <string name="clear_user_data_text" msgid="355574089263023363">"Vymazat úložiště"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Odinstalovat aktualizace"</string>
    <string name="auto_launch_enable_text" msgid="4275746249511874845">"Aplikace byla nastavena, aby se pro některé akce spouštěla jako výchozí."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="566822577792032925">"Této aplikaci jste povolili vytváření widgetů a přístup k jejich datům."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Není nastavena jako výchozí pro žádné akce"</string>
    <string name="clear_activities" msgid="7408923511535174430">"Vymazat výchozí nastavení"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Tato aplikace nejspíš není určena pro vaši obrazovku. Zde můžete nastavit, jak se aplikace obrazovce přizpůsobí."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Dotázat se při spuštění"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Upravit velikost aplikace"</string>
    <string name="unknown" msgid="1592123443519355854">"Neznámé"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Seřadit podle jména"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Řadit podle velikosti"</string>
    <string name="sort_order_recent_notification" msgid="6064103501358974282">"Nejnovější"</string>
    <string name="sort_order_frequent_notification" msgid="1733204081305830670">"Nejčastější"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Zobrazit spuštěné služby"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Zobrazit mezipaměť"</string>
    <string name="default_emergency_app" msgid="1951760659640369980">"Aplikace k příjmu výstražných zpráv"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Obnovit nastavení aplikací"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Obnovit nastavení aplikací?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"Tímto obnovíte všechna nastavení následujících položek:\n\n "<li>"deaktivované aplikace,"</li>\n" "<li>"deaktivovaná oznámení aplikací,"</li>\n" "<li>"výchozí aplikace pro různé akce,"</li>\n" "<li>"omezení datových přenosů na pozadí pro aplikace,"</li>\n" "<li>"veškerá omezení oprávnění."</li>\n\n" Nepřijdete o žádná data aplikací."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Obnovit aplikace"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Správa paměti"</string>
    <string name="filter" msgid="2018011724373033887">"Filtrovat"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Vyberte možnosti filtru"</string>
    <string name="filter_apps_all" msgid="8899612398848280352">"Všechny aplikace"</string>
    <string name="filter_apps_disabled" msgid="5862632369555319938">"Deaktivované aplikace"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Stažené"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Spuštěné"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Úložiště USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Na kartě SD"</string>
    <string name="not_installed" msgid="2797554494953450291">"Pro tohoto uživ. nenainstal."</string>
    <string name="installed" msgid="3070865169422600098">"Nainstalováno"</string>
    <string name="no_applications" msgid="7336588977497084921">"Žádné aplikace"</string>
    <string name="internal_storage" msgid="1584700623164275282">"Interní úložiště"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Přepočítávání velikosti..."</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Vymazat data aplikace?"</string>
    <string name="clear_data_dlg_text" msgid="3951297329833822490">"Veškerá data (všechny soubory, nastavení, účty, databáze apod.) této aplikace budou trvale vymazána."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"OK"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Zrušit"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="4893589904687340011">"Aplikaci se nepodařilo najít na seznamu nainstalovaných aplikací."</string>
    <string name="clear_failed_dlg_text" msgid="8651231637137025815">"Data aplikace v úložišti se nepodařilo vymazat."</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> a <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_two_unrelated_items" msgid="1873827777191260824">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="computing_size" msgid="1599186977475211186">"Probíhá výpočet…"</string>
    <string name="invalid_size_value" msgid="1582744272718752951">"Nepodařilo se určit velikost balíčku."</string>
    <string name="version_text" msgid="9189073826278676425">"verze <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Přesunout"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Přesunout do tabletu"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Přesunout do telefonu"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Přesunout do úlož. USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Přesunout na kartu SD"</string>
    <string name="another_migration_already_in_progress" msgid="7817354268848365487">"Probíhá jiná migrace."</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Nedostatek místa v úložišti."</string>
    <string name="does_not_exist" msgid="1501243985586067053">"Aplikace neexistuje."</string>
    <string name="invalid_location" msgid="4354595459063675191">"Umístění instalace není platné."</string>
    <string name="system_package" msgid="1352722848400644991">"Aktualizace systému nelze nainstalovat na externí média."</string>
    <string name="move_error_device_admin" msgid="8673026002690505763">"Aplikaci pro správu zařízení nelze nainstalovat na externí média"</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Chcete vynutit zastavení?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Vynucené zastavení může způsobit nepředvídatelné chování aplikace."</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Preferované umístění pro instalaci"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Změna preferovaného umístění pro instalaci nových aplikací"</string>
    <string name="app_disable_dlg_positive" msgid="7375627244201714263">"Deaktivovat aplikaci"</string>
    <string name="app_disable_dlg_text" msgid="1234624266290478136">"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_disable_notifications_dlg_title" msgid="7669264654851761857">"Vypnout oznámení?"</string>
    <string name="app_install_details_group_title" msgid="7084623031296083574">"Obchod"</string>
    <string name="app_install_details_title" msgid="6905279702654975207">"Podrobnosti o aplikaci"</string>
    <string name="app_install_details_summary" msgid="6464796332049327547">"Aplikace nainstalovaná z obchodu <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="4529934403276907045">"Další informace: <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"Spuštěno"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Nebylo použito)"</string>
    <string name="no_default_apps" msgid="2915315663141025400">"Žádné výchozí aplikace"</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Využití úložiště"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Zobrazit aplikacemi používané úložiště"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Probíhá restartování"</string>
    <string name="cached" msgid="1059590879740175019">"Proces na pozadí v mezipaměti"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Nic není spuštěno."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Spuštěno aplikací."</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"Volno: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"Využito: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Uživatel: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Odebraný uživatel"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_header_title" msgid="6588371727640789560">"Paměť zařízení"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Využití paměti RAM aplikacemi"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Systém"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Aplikace"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"Volná"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Využito"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"V mezipaměti"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Spuštěná aplikace"</string>
    <string name="no_services" msgid="7133900764462288263">"Neaktivní"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Služby"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Procesy"</string>
    <string name="service_stop" msgid="6369807553277527248">"Zastavit"</string>
    <string name="service_manage" msgid="1876642087421959194">"Nastavení"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Tato služba byla spuštěna svou aplikací. Pokud ji zastavíte, může dojít k selhání aplikace."</string>
    <string name="heavy_weight_stop_description" msgid="6050413065144035971">"Tuto aplikaci nemůžete bezpečně ukončit. Mohlo by dojít ke ztrátě části vaší aktuální práce."</string>
    <string name="background_process_stop_description" msgid="3834163804031287685">"Toto je starý proces aplikace, který je spuštěn pro případ, že bude znovu potřeba. Zpravidla není důvod jej zastavovat."</string>
    <string name="service_manage_description" msgid="479683614471552426">"<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="1130702347066340890">"Hlavní proces, který se používá."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Služba <xliff:g id="COMP_NAME">%1$s</xliff:g> se používá."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Poskytovatel <xliff:g id="COMP_NAME">%1$s</xliff:g> se používá."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Zastavit systémovou službu?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Pokud tuto službu zastavíte, může se stát, že některé funkce telefonu nebudou fungovat správně, dokud telefon nevypnete a opět nezapnete."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Pokud tuto službu zastavíte, může se stát, že některé funkce tabletu nebudou fungovat správně, dokud telefon nevypnete a opět nezapnete."</string>
    <string name="language_input_gesture_title" msgid="8749227808244881255">"Jazyky, vstup a gesta"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="7219895055450633449"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="756147879200943161"></string>
    <string name="language_input_gesture_summary_off" msgid="4617198819416948217"></string>
    <string name="language_settings" msgid="8758655933029560944">"Jazyky a zadávání"</string>
    <string name="language_empty_list_user_restricted" msgid="5984015900102140696">"Ke změně jazyka zařízení nemáte oprávnění."</string>
    <string name="language_keyboard_settings_title" msgid="3709159207482544398">"Jazyky a zadávání"</string>
    <string name="input_assistance" msgid="7392740255874966807">"Nástroje"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Klávesnice a metody zadávání"</string>
    <string name="phone_language" msgid="7116581601133118044">"Jazyky"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Automatické nahrazování"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Opravovat pravopisné chyby"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Velká písmena automaticky"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"První písmeno ve větě je automaticky velké"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Automatická interpunkce"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Nastavení fyzické klávesnice"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Znak „.“ lze vložit dvojím stisknutím klávesy Mezerník."</string>
    <string name="show_password" msgid="4837897357002495384">"Zobrazovat hesla"</string>
    <string name="show_password_summary" msgid="3365397574784829969">"Při psaní se budou krátce zobrazovat zadané znaky"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Prostřednictvím této kontroly pravopisu lze shromažďovat zadaný text včetně osobních údajů, jako jsou hesla a čísla kreditních karet. Kontrola pravopisu je součástí aplikace <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Chcete tuto kontrolu pravopisu použít?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Nastavení"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Jazyk"</string>
    <string name="keyboard_and_input_methods_category" msgid="4580907662493721491">"Klávesnice"</string>
    <string name="virtual_keyboard_category" msgid="1012830752318677119">"Virtuální klávesnice"</string>
    <string name="available_virtual_keyboard_category" msgid="7645766574969139819">"Dostupná virtuální klávesnice"</string>
    <string name="add_virtual_keyboard" msgid="3302152381456516928">"Spravovat klávesnice"</string>
    <string name="keyboard_assistance_category" msgid="5843634175231134014">"Asistence ke klávesnici"</string>
    <string name="physical_keyboard_title" msgid="8285149877925752042">"Fyzická klávesnice"</string>
    <string name="show_ime" msgid="2658582193437188227">"Zobrazit virtuální klávesnici"</string>
    <string name="show_ime_summary" msgid="8164993045923240698">"Ponechat na obrazovce, když je aktivní fyzická klávesnice"</string>
    <string name="keyboard_shortcuts_helper" msgid="4839453720463798145">"Nápověda ke klávesovým zkratkám"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5871299901459743288">"Zobrazit dostupné klávesové zkratky"</string>
    <string name="language_and_input_for_work_category_title" msgid="3825906835886710498">"Klávesnice a nástroje v pracovním profilu"</string>
    <string name="virtual_keyboards_for_work_title" msgid="2646946676585390499">"Virtuální klávesnice pro práci"</string>
    <string name="default_keyboard_layout" msgid="4172606673510531271">"Výchozí"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Rychlost kurzoru"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Herní ovladače"</string>
    <string name="vibrate_input_devices" msgid="421936611134697943">"Vibrace při přesměrování"</string>
    <string name="vibrate_input_devices_summary" msgid="82093256723774584">"Odeslat vibrace do herního ovladače, je-li připojen"</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Zvolte rozložení klávesnice"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Nastavit rozvržení klávesnice"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Přepněte klávesami ctrl+mezerník"</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Výchozí"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Rozložení klávesnice"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Vlastní slovník"</string>
    <string name="user_dict_settings_for_work_title" msgid="7634659414713254169">"Osobní slovník pro práci"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Přidat"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Přidat do slovníku"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Fráze"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Více možností"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Méně možností"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Slovo:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Zkratka:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Jazyk:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Napište slovo"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Volitelná zkratka"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Upravit slovo"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Upravit"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Smazat"</string>
    <string name="user_dict_settings_empty_text" msgid="1971969756133074922">"V uživatelském slovníku nejsou žádná slova. Chcete-li slovo přidat, klepněte na tlačítko Přidat (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Pro všechny jazyky"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Další jazyky..."</string>
    <string name="testing" msgid="6584352735303604146">"Testování"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informace o tabletu"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Informace o telefonu"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Zadávání textu"</string>
    <string name="input_method" msgid="5434026103176856164">"Metoda zadávání dat"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Aktuální klávesnice"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Výběr metody zadávání"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automaticky"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Vždy zobrazovat"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Vždy skrývat"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Nastavit metody zadávání"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Nastavení"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Nastavení"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Nastavení modulu <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Vybrat aktivní metody zadávání"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Nastavení softwarové klávesnice"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Fyzická klávesnice"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Nastavení fyzické klávesnice"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Zvolte gadget"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Zvolte widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Vytvořit widget a povolit přístup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Po vytvoření widgetu bude moci aplikace <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> získat přístup ke všem datům, které widget zobrazuje."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Vždy povolit aplikaci <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> vytváření widgetů a přístup k jejich datům"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Statistika použití"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Statistika použití"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Řadit podle:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplikace"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Naposledy použito"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Doba použití"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Přístupnost"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Nastavení přístupnosti"</string>
    <string name="accessibility_settings_summary" msgid="981260486011624939">"Čtečky obrazovky, zobrazení, interaktivní ovládací prvky"</string>
    <string name="vision_settings_title" msgid="4204111425716868288">"Nastavení pro slabozraké"</string>
    <string name="vision_settings_description" msgid="5679491180156408260">"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="8058794060304707004">"Změňte velikost písma"</string>
    <string name="screen_reader_category_title" msgid="7739154903913400641">"Čtečky obrazovky"</string>
    <string name="audio_and_captions_category_title" msgid="3420727114421447524">"Zvuk a text na obrazovce"</string>
    <string name="display_category_title" msgid="685461049938269166">"Zobrazení"</string>
    <string name="interaction_control_category_title" msgid="7836591031872839151">"Interaktivní ovládací prvky"</string>
    <string name="user_installed_services_category_title" msgid="6426376488922158647">"Stažené služby"</string>
    <string name="experimental_category_title" msgid="5272318666666893547">"Experimentální"</string>
    <string name="feature_flags_dashboard_title" msgid="778619522682769966">"Příznaky experimentálních funkcí"</string>
    <string name="talkback_title" msgid="7912059827205988080">"TalkBack"</string>
    <string name="talkback_summary" msgid="8331244650729024963">"Čtečka obrazovky určená primárně pro nevidomé a slabozraké"</string>
    <string name="select_to_speak_summary" msgid="4282846695497544515">"Klepněte na položky na obrazovce, které chcete přečíst"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Titulky"</string>
    <string name="accessibility_screen_magnification_title" msgid="6001128808776506021">"Zvětšení"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3719929521571489913">"Zvětšení trojitým klepnutím"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="7141753038957538230">"Zvětšení tlačítkem"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="2760906043221923793">"Zvětšení tlačítkem a trojitým klepnutím"</string>
    <string name="accessibility_preference_magnification_summary" msgid="5867883657521404509">"Přiblížení obrazovky"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="3411979839172752057">"Trojitým klepnutím aktivujete přiblížení"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="3693116360267980492">"Přiblížení zobrazení klepnutím na tlačítko"</string>
    <string name="accessibility_screen_magnification_summary" msgid="5258868553337478505"><b>"Přiblížení"</b>" provedete tak, že třikrát klepnete na obrazovku.\n"<ul><li>"Přetažením dvěma prsty zobrazení posunete."</li>\n<li>"Úroveň přiblížení upravíte stažením nebo roztažením dvou nebo více prstů."</li></ul>\n\n"Chcete-li zobrazení "<b>"přiblížit dočasně"</b>", rychle na obrazovku klepněte třikrát za sebou a při posledním klepnutí prst přidržte.\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_screen_magnification_navbar_summary" msgid="1996584694050087161">"Když je zapnuto zvětšení, lze pomocí tlačítka Přístupnost v dolní části obrazovky rychle zvětšit zobrazení.\n\n"<b>"Přiblížení"</b>" provedete tak, že klepnete na tlačítko Přístupnost a poté na libovolné místo na obrazovce.\n"<ul><li>"Přetažením dvěma prsty zobrazení posunete."</li>\n<li>"Úroveň přiblížení upravíte stažením nebo roztažením dvou nebo více prstů."</li></ul>\n\n"Chcete-li zobrazení "<b>"přiblížit dočasně"</b>", klepněte na tlačítko Přístupnost a poté klepněte na libovolné místo 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_screen_magnification_navbar_configuration_warning" msgid="70533120652758190">"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_global_gesture_preference_title" msgid="2048884356166982714">"Zkratka tlačítka hlasitosti"</string>
    <string name="accessibility_shortcut_service_title" msgid="4779360749706905640">"Služba ovládaná zkratkou"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="5490636079625489534">"Povolit na obrazovce uzamčení"</string>
    <string name="accessibility_shortcut_description" msgid="1765853731190717372">"Když je tato zkratka zapnutá, můžete funkci přístupnosti spustit tím, že na tři sekundy podržíte obě tlačítka hlasitosti."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Text s vysokým kontrastem"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Automaticky aktualizovat přiblížení"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Aktual. přiblížení obrazovky při přepnutí aplikací"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Vypínač ukončí hovor"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="535173100516295580">"Velký kurzor myši"</string>
    <string name="accessibility_disable_animations" msgid="5876035711526394795">"Odstranit animace"</string>
    <string name="accessibility_toggle_master_mono_title" msgid="4363806997971905302">"Zvuk mono"</string>
    <string name="accessibility_toggle_master_mono_summary" msgid="5634277025251530927">"Při přehrávání zvuku kombinovat kanály"</string>
    <string name="accessibility_toggle_master_balance_title" msgid="551441665399043471">"Balance zvuku"</string>
    <string name="accessibility_toggle_master_balance_left_label" msgid="840973259765894310">"Vlevo"</string>
    <string name="accessibility_toggle_master_balance_right_label" msgid="7349959407092157385">"Vpravo"</string>
    <string name="accessibility_timeout_default" msgid="8316215621219570607">"Výchozí"</string>
    <string name="accessibility_timeout_10secs" msgid="1976492627730727871">"10 sekund"</string>
    <string name="accessibility_timeout_30secs" msgid="8055710148052265579">"30 sekund"</string>
    <string name="accessibility_timeout_1min" msgid="6314276027668784112">"1 minuta"</string>
    <string name="accessibility_timeout_2mins" msgid="9062685014853095180">"2 minuty"</string>
    <string name="accessibility_content_timeout_preference_title" msgid="5647118549024271497">"Čas na přečtení"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="3076566452307147390">"Čas na akci"</string>
    <string name="accessibility_content_timeout_preference_summary" msgid="2637322628166175371">"Určete, jak dlouho se mají zobrazovat důležité zprávy, které jsou viditelné jen po omezenou dobu.\n\nToto nastavení podporují jen některé aplikace."</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="6557680564604287459">"Určete, jak dlouho se mají zobrazovat zprávy s výzvami k akci, které jsou viditelné jen po omezenou dobu.\n\nToto nastavení podporují jen některé aplikace."</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Prodleva přidržení"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Převrácení barev"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="7052959202195368109">"Toto nastavení může mít dopad na výkon"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2434062071927416098">"Doba setrvání"</string>
    <string name="accessibility_autoclick_description" msgid="4908960598910896933">"Pokud používáte myš, můžete kurzor nastavit tak, aby automaticky klikl, jakmile se na určitou dobu zastaví."</string>
    <string name="accessibility_autoclick_delay_preference_title" msgid="3962261178385106006">"Prodleva před kliknutím"</string>
    <string name="accessibility_vibration_settings_title" msgid="3453277326300320803">"Vibrace"</string>
    <string name="accessibility_notification_vibration_title" msgid="3009997451790678444">"Vibrace při oznámení"</string>
    <string name="accessibility_ring_vibration_title" msgid="5369395955680650778">"Vibrace při vyzvánění"</string>
    <string name="accessibility_touch_vibration_title" msgid="7931823772673770492">"Vibrace dotykové obrazovky"</string>
    <string name="accessibility_service_master_switch_title" msgid="6835441300276358239">"Používat službu"</string>
    <string name="accessibility_daltonizer_master_switch_title" msgid="8655284637968823154">"Používat korekci barev"</string>
    <string name="accessibility_caption_master_switch_title" msgid="4010227386676077826">"Používat titulky"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="974461729380409972">"Pokračovat"</string>
    <string name="accessibility_hearingaid_title" msgid="8312145423610648518">"Naslouchátka"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="6240237523789614599">"Nejsou připojena žádná naslouchátka"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="2947474468412309778">"Přidat naslouchátka"</string>
    <string name="accessibility_hearingaid_pair_instructions_first_message" msgid="3912093691643131154">"Chcete-li spárovat naslouchátka, na další obrazovce najděte své zařízení a klepněte na něj."</string>
    <string name="accessibility_hearingaid_pair_instructions_second_message" msgid="5596683393607650243">"Ujistěte se, zda jsou naslouchátka v režimu párování."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="3924362383258688984">"Zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> je aktivní"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="3160782397139295486">
      <item quantity="few"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> uložená naslouchátka</item>
      <item quantity="many"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> uloženého naslouchátka</item>
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> uložených naslouchátek</item>
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_0">%1$d</xliff:g> uložené naslouchátko</item>
    </plurals>
    <string name="accessibility_summary_state_enabled" msgid="7914278500885887763">"Zapnuto"</string>
    <string name="accessibility_summary_state_disabled" msgid="2984230257590246745">"Vypnuto"</string>
    <string name="accessibility_summary_state_stopped" msgid="1144156815350270876">"Nefunguje. Klepnutím zobrazíte informace."</string>
    <string name="accessibility_description_state_stopped" msgid="6953539746047006596">"Tato služba nefunguje."</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Zobrazit v rychlém nastavení"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Režim korekce"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_extremely_short_delay" formatted="false" msgid="7340347830562315800">
      <item quantity="few">Mimořádně krátká prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="many">Mimořádně krátká prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Mimořádně krátká prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Mimořádně krátká prodleva (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_short_delay" formatted="false" msgid="5589565607652364932">
      <item quantity="few">Velmi krátká prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="many">Velmi krátká prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Velmi krátká prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Velmi krátká prodleva (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5887754135102768400">
      <item quantity="few">Krátká prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="many">Krátká prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Krátká prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Krátká prodleva (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="6340683412750219405">
      <item quantity="few">Dlouhá prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="many">Dlouhá prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Dlouhá prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Dlouhá prodleva (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_long_delay" formatted="false" msgid="3503199424330634970">
      <item quantity="few">Velmi dlouhá prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="many">Velmi dlouhá prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Velmi dlouhá prodleva (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Velmi dlouhá prodleva (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <string name="accessibility_vibration_summary" msgid="4272038147476749536">"Vyzvánění <xliff:g id="SUMMARY_RING">%1$s</xliff:g>, oznámení <xliff:g id="SUMMARY_NOTIFICATION">%2$s</xliff:g>, klepnutí <xliff:g id="SUMMARY_TOUCH">%3$s</xliff:g>"</string>
    <string name="accessibility_vibration_summary_off" msgid="1753566394591809629">"Vibrace pro vyzvánění a oznámení jsou vypnuty"</string>
    <string name="accessibility_vibration_summary_low" msgid="7628418309029013867">"Pro vyzvánění a oznámení jsou nastaveny slabé vibrace"</string>
    <string name="accessibility_vibration_summary_medium" msgid="3422136736880414093">"Pro vyzvánění a oznámení jsou nastaveny střední vibrace"</string>
    <string name="accessibility_vibration_summary_high" msgid="3239807793182635729">"Pro vyzvánění a oznámení jsou nastaveny silné vibrace"</string>
    <string name="accessibility_vibration_intensity_off" msgid="4613890213008630847">"Vypnuto"</string>
    <string name="accessibility_vibration_intensity_low" msgid="2017572546489862987">"Slabé"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="3782136025830279769">"Střední"</string>
    <string name="accessibility_vibration_intensity_high" msgid="2543921139337952491">"Silné"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Nastavení"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Zapnuto"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Vypnuto"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Náhled"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Standardní možnosti"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Jazyk"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Velikost textu"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Styl titulků"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Vlastní možnosti"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Barva pozadí"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Neprůhlednost pozadí"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Barva okna titulků"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Neprůhlednost okna titulků"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Barva textu"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Neprůhlednost textu"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Barva okraje"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Typ okraje"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Rodina písem"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Titulky budou vypadat takto"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Výchozí"</string>
    <string name="color_title" msgid="4258931051732243983">"Barva"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"Výchozí"</string>
    <string name="color_none" msgid="3475640044925814795">"Žádná"</string>
    <string name="color_white" msgid="8045195170201590239">"Bílá"</string>
    <string name="color_gray" msgid="9192312087142726313">"Šedá"</string>
    <string name="color_black" msgid="7517353520909872561">"Černá"</string>
    <string name="color_red" msgid="4949354900304125428">"Červená"</string>
    <string name="color_green" msgid="5537717328428845841">"Zelená"</string>
    <string name="color_blue" msgid="7731984529016953223">"Modrá"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Tyrkysová"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Žlutá"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Purpurová"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Zapnout <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"<xliff:g id="SERVICE">%1$s</xliff:g> potřebuje:"</string>
    <string name="touch_filtered_warning" msgid="8644034725268915030">"Žádost o oprávnění je blokována jinou aplikací. Nastavení proto vaši odpověď nemůže ověřit."</string>
    <string name="enable_service_encryption_warning" msgid="3064686622453974606">"Pokud zapnete službu <xliff:g id="SERVICE">%1$s</xliff:g>, zařízení nebude používat zámek obrazovky k vylepšení šifrování dat."</string>
    <string name="secure_lock_encryption_warning" msgid="460911459695077779">"Vzhledem k tomu, že jste zapnuli službu přístupnosti, nebude zařízení používat zámek obrazovky k vylepšení šifrování dat."</string>
    <string name="enable_service_pattern_reason" msgid="777577618063306751">"Protože zapnutí služby <xliff:g id="SERVICE">%1$s</xliff:g> má vliv na šifrování dat, je třeba, abyste potvrdili své gesto."</string>
    <string name="enable_service_pin_reason" msgid="7882035264853248228">"Protože zapnutí služby <xliff:g id="SERVICE">%1$s</xliff:g> má vliv na šifrování dat, je třeba, abyste potvrdili svůj kód PIN."</string>
    <string name="enable_service_password_reason" msgid="1224075277603097951">"Protože zapnutí služby <xliff:g id="SERVICE">%1$s</xliff:g> má vliv na šifrování dat, je třeba, abyste potvrdili své heslo."</string>
    <string name="accessibility_service_warning" msgid="846312597054899472">"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="disable_service_title" msgid="3624005212728512896">"Vypnout funkci <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="2247101878627941561">"Klepnutím na tlačítko OK službu <xliff:g id="SERVICE">%1$s</xliff:g> ukončíte."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Žádná služba není nainstalována"</string>
    <string name="accessibility_no_service_selected" msgid="2840969718780083998">"Není vybrána žádná služba"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"K dispozici není žádný popis."</string>
    <string name="settings_button" msgid="3006713718908152930">"Nastavení"</string>
    <string name="print_settings" msgid="4742428530112487843">"Tisk"</string>
    <string name="print_settings_summary_no_service" msgid="6354322414246865875">"Vypnuto"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="6005468025646083029">
      <item quantity="few">Jsou zapnuté <xliff:g id="COUNT">%1$d</xliff:g> tiskové služby</item>
      <item quantity="many">Je zapnuto <xliff:g id="COUNT">%1$d</xliff:g> tiskové služby</item>
      <item quantity="other">Je zapnuto <xliff:g id="COUNT">%1$d</xliff:g> tiskových služeb</item>
      <item quantity="one">Je zapnutá 1 tisková služba</item>
    </plurals>
    <plurals name="print_jobs_summary" formatted="false" msgid="5810106725778525400">
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> tiskové úlohy</item>
      <item quantity="many"><xliff:g id="COUNT">%1$d</xliff:g> tiskové úlohy</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> tiskových úloh</item>
      <item quantity="one">1 tisková úloha</item>
    </plurals>
    <string name="print_settings_title" msgid="3685449667822217816">"Tiskové služby"</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Žádná služba není nainstalována"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Nebyly nalezeny žádné tiskárny"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Nastavení"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Přidat tiskárny"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Zapnuto"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Vypnuto"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Přidat službu"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Přidat tiskárnu"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Vyhledávání"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Vyhledávání tiskáren"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Služba je vypnuta"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Tiskové úlohy"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Tisková úloha"</string>
    <string name="print_restart" msgid="8373999687329384202">"Restartovat"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Storno"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="1228890182762324249">"Konfigurace úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Tisk úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Rušení úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Chyba tiskárny u úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Tiskárna blokuje úlohu <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Vyhledávací pole se zobrazuje"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Vyhledávací pole je skryto"</string>
    <string name="printer_info_desc" msgid="5824995108703060003">"Další informace o této tiskárně"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Baterie"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Co využívá baterii"</string>
    <string name="power_usage_not_available" msgid="3109326074656512387">"Údaje o spotřebě nejsou známy."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"Zbývá <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do nabití"</string>
    <string name="background_activity_title" msgid="8482171736539410135">"Omezení na pozadí"</string>
    <string name="background_activity_summary" msgid="8140094430510517362">"Povolit aplikaci spouštění na pozadí"</string>
    <string name="background_activity_summary_disabled" msgid="3710669050484599847">"Aplikace nemá povoleno spouštění na pozadí"</string>
    <string name="background_activity_summary_whitelisted" msgid="1079899502347973947">"Využití na pozadí omezit nelze"</string>
    <string name="background_activity_warning_dialog_title" msgid="2216249969149568871">"Omezit aktivitu na pozadí?"</string>
    <string name="background_activity_warning_dialog_text" msgid="7049624449246121981">"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="6133420589651880824">"Aplikace není nastavena k optimalizaci baterie, nelze ji tedy omezit.\n\nChcete-li ji omezit, nejprve zapněte optimalizaci."</string>
    <string name="device_screen_usage" msgid="3386088035570409683">"Využití obrazovky od úplného nabití"</string>
    <string name="power_usage_list_summary" msgid="5584049564906462506">"Využití baterie od úplného nabití"</string>
    <string name="screen_usage_summary" msgid="6687403051423153550">"Doba, po kterou byla od úplného nabití zapnutá obrazovka"</string>
    <string name="device_usage_list_summary" msgid="5623036661468763251">"Využití zařízení od úplného nabití"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Využití baterie od odpojení"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Využití baterie od obnovení"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"Provoz na baterii: <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> od odpojení"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Nabíjení"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Zapnutá obrazovka"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"Zapnutá GPS"</string>
    <string name="battery_stats_camera_on_label" msgid="4935637383628414968">"Fotoaparát je zapnutý"</string>
    <string name="battery_stats_flashlight_on_label" msgid="4319637669889411307">"Svítilna je zapnutá"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Aktivní režim"</string>
    <string name="battery_stats_phone_signal_label" msgid="4137799310329041341">"Signál mobilní sítě"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Doba provozu zařízení"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Doba provozu Wi-Fi"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Doba provozu modulu Wi-Fi"</string>
    <string name="advanced_battery_title" msgid="6768618303037280828">"Využití baterie"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Podrobnosti historie"</string>
    <string name="battery_details_title" msgid="6101394441569858580">"Využití baterie"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Podrobnosti využívání"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Upravit spotřebu energie"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Zahrnuté balíčky"</string>
    <string name="battery_tip_summary_title" msgid="368729969313047399">"Aplikace běží normálně"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="2198778125778121221">"V telefonu dochází k běžnému využití baterie na pozadí"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="1183976728682325345">"V tabletu dochází k běžnému využití baterie na pozadí"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="363718204492523920">"V zařízení dochází k běžnému využití baterie na pozadí"</string>
    <string name="battery_tip_low_battery_title" msgid="5103420355109677385">"Nízká kapacita baterie"</string>
    <string name="battery_tip_low_battery_summary" msgid="4702986182940709150">"Baterie není schopna zajistit dobrou výdrž"</string>
    <string name="battery_tip_smart_battery_title" product="default" msgid="2542822112725248683">"Zvyšte životnost baterie telefonu"</string>
    <string name="battery_tip_smart_battery_title" product="tablet" msgid="6452567046912954866">"Zvyšte životnost baterie tabletu"</string>
    <string name="battery_tip_smart_battery_title" product="device" msgid="4445149029390556382">"Zvyšte životnost baterie zařízení"</string>
    <string name="battery_tip_smart_battery_summary" msgid="2326809294592208069">"Zapnout Správce baterie"</string>
    <string name="battery_tip_early_heads_up_title" msgid="5788492366387119807">"Zapnout spořič baterie"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="1639271439914224547">"Baterie se možná vybije dříve než obvykle"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="4294083319255926811">"Spořič baterie je zapnutý"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7054036010928794364">"Některé funkce mohou být omezeny"</string>
    <string name="battery_tip_high_usage_title" product="default" msgid="1282187115295901930">"Telefon byl využíván víc než obvykle"</string>
    <string name="battery_tip_high_usage_title" product="tablet" msgid="7422137233845959351">"Tablet byl využíván víc než obvykle"</string>
    <string name="battery_tip_high_usage_title" product="device" msgid="5483320224273724068">"Zařízení bylo využíváno víc než obvykle"</string>
    <string name="battery_tip_high_usage_summary" msgid="5343363604280323738">"Baterie se možná vybije dříve než obvykle"</string>
    <!-- no translation found for battery_tip_dialog_message (797225122502556066) -->
    <skip />
    <!-- no translation found for battery_tip_dialog_message (49788591262480482) -->
    <skip />
    <!-- no translation found for battery_tip_dialog_message (7959652003221931962) -->
    <skip />
    <string name="battery_tip_dialog_message_footer" msgid="2560019187096011163">"Zahrnuje energeticky náročnou aktivitu na pozadí"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="467228882789275512">
      <item quantity="few">Omezit %1$d aplikace</item>
      <item quantity="many">Omezit %1$d aplikace</item>
      <item quantity="other">Omezit %1$d aplikací</item>
      <item quantity="one">Omezit %1$d aplikaci</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_title" formatted="false" msgid="2996094393897875408">
      <item quantity="few">%2$d aplikace byly nedávno omezeny</item>
      <item quantity="many">%2$d aplikace bylo nedávno omezeno</item>
      <item quantity="other">%2$d aplikací bylo nedávno omezeno</item>
      <item quantity="one">%1$s aplikace byla nedávno omezena</item>
    </plurals>
    <plurals name="battery_tip_restrict_summary" formatted="false" msgid="5768962491638423979">
      <item quantity="few">%2$d aplikace způsobují vysoké využití baterie na pozadí</item>
      <item quantity="many">%2$d aplikace způsobuje vysoké využití baterie na pozadí</item>
      <item quantity="other">%2$d aplikací způsobuje vysoké využití baterie na pozadí</item>
      <item quantity="one">%1$s aplikace způsobuje vysoké využití baterie na pozadí</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="1040488674178753191">
      <item quantity="few">Tyto aplikace nelze spustit na pozadí</item>
      <item quantity="many">Tyto aplikace nelze spustit na pozadí</item>
      <item quantity="other">Tyto aplikace nelze spustit na pozadí</item>
      <item quantity="one">Tuto aplikaci nelze spustit na pozadí</item>
    </plurals>
    <plurals name="battery_tip_restrict_app_dialog_title" formatted="false" msgid="8130618585820429591">
      <item quantity="few">Omezit %1$d aplikace?</item>
      <item quantity="many">Omezit %1$d aplikace?</item>
      <item quantity="other">Omezit %1$d aplikací?</item>
      <item quantity="one">Omezit aplikaci?</item>
    </plurals>
    <string name="battery_tip_restrict_app_dialog_message" msgid="7271391929137806299">"Chcete-li 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="3175700359860699627">"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="582641081128076191">"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="8291115820018013353">"Omezit"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="4321334634106715162">"Odstranit omezení?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="6537761705584610231">"Aplikace bude moci využívat baterii na pozadí. Baterie se možná vybije dříve, než bylo očekáváno."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="6022058431218137646">"Odebrat"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="3058235875830858902">"Zrušit"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="4628448253185085796">"Vaše aplikace mají běžnou spotřebu baterie. Pokud dojde k velkému zvýšení spotřeby, telefon vám doporučí možné akce.\n\nPokud vám dochází baterie, můžete podle potřeby zapnout spořič baterie."</string>
    <string name="battery_tip_dialog_summary_message" product="tablet" msgid="8327950887399420971">"Vaše aplikace mají běžnou spotřebu baterie. Pokud dojde k velkému zvýšení spotřeby, tablet vám doporučí možné akce.\n\nPokud vám dochází baterie, můžete podle potřeby zapnout spořič baterie."</string>
    <string name="battery_tip_dialog_summary_message" product="device" msgid="6753742263807939789">"Vaše aplikace mají běžnou spotřebu baterie. Pokud dojde k velkému zvýšení spotřeby, zařízení vám doporučí možné akce.\n\nPokud vám dochází baterie, můžete podle potřeby zapnout spořič baterie."</string>
    <string name="smart_battery_manager_title" msgid="870632749556793417">"Správce baterie"</string>
    <string name="smart_battery_title" msgid="6218785691872466076">"Automatická správa aplikací"</string>
    <string name="smart_battery_summary" msgid="1339184602000004058">"Omezte využití baterie u aplikací, které používáte zřídka"</string>
    <string name="smart_battery_footer" product="default" msgid="5555604955956219544">"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="smart_battery_footer" product="tablet" msgid="5555604955956219544">"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="smart_battery_footer" product="device" msgid="5555604955956219544">"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="8982477293044330653">"Omezené aplikace"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="7355687633914223530">
      <item quantity="few">Omezení využití baterie u %1$d aplikací</item>
      <item quantity="many">Omezení využití baterie u %1$d aplikace</item>
      <item quantity="other">Omezení využití baterie u %1$d aplikací</item>
      <item quantity="one">Omezení využití baterie u %1$d aplikace</item>
    </plurals>
    <string name="restricted_app_time_summary" msgid="6983512391277778623">"Omezeno <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="6739863162364046859">"Tyto aplikace využívají baterii na pozadí. Omezené aplikace nemusí fungovat správně a jejich oznámení se mohou zobrazovat se zpožděním."</string>
    <string name="battery_auto_restriction_title" msgid="6553271897488963709">"Použít správce baterie"</string>
    <string name="battery_auto_restriction_summary" msgid="8561335400991281062">"Zjišťovat, zda aplikace vybíjejí baterii"</string>
    <string name="battery_manager_on" msgid="8643310865054362396">"Zapnuto / Zjišťování, zda aplikace vybíjejí baterii"</string>
    <string name="battery_manager_off" msgid="5473135235710343576">"Vypnuto"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="1026141135861471129">
      <item quantity="few">Jsou omezeny %1$d aplikace</item>
      <item quantity="many">Je omezeno %1$d aplikace</item>
      <item quantity="other">Je omezeno %1$d aplikací</item>
      <item quantity="one">Je omezena %1$d aplikace</item>
    </plurals>
    <string name="battery_header_title_alternate" msgid="1766047545950757380">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="dialog_stop_title" msgid="6395127715596746479">"Zastavit aplikaci?"</string>
    <string name="dialog_stop_message" product="default" msgid="4006631636646776488">"Telefon nemůže normálně šetřit baterii, protože mu aplikace <xliff:g id="APP">%1$s</xliff:g> znemožňuje přejít do režimu spánku.\n\nTento problém můžete zkusit vyřešit tím, že aplikaci ukončíte.\n\nPokud se to bude dít neustále, kvůli prodloužení výdrže baterie bude aplikaci možná nutné odinstalovat."</string>
    <string name="dialog_stop_message" product="tablet" msgid="2369957934555162428">"Tablet nemůže normálně šetřit baterii, protože mu aplikace <xliff:g id="APP">%1$s</xliff:g> znemožňuje přejít do režimu spánku.\n\nTento problém můžete zkusit vyřešit tím, že aplikaci ukončíte.\n\nPokud se to bude dít neustále, kvůli prodloužení výdrže baterie bude aplikaci možná nutné odinstalovat."</string>
    <string name="dialog_stop_message" product="device" msgid="6195430620406365292">"Zařízení nemůže normálně šetřit baterii, protože mu aplikace <xliff:g id="APP">%1$s</xliff:g> znemožňuje přejít do režimu spánku.\n\nTento problém můžete zkusit vyřešit tím, že aplikaci ukončíte.\n\nPokud se to bude dít neustále, kvůli prodloužení výdrže baterie bude aplikaci možná nutné odinstalovat."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="default" msgid="1638726742782558262">"Telefon nemůže normálně šetřit baterii, protože jej aplikace <xliff:g id="APP_0">%1$s</xliff:g> neustále budí.\n\nTento problém můžete vyřešit tím, že aplikaci <xliff:g id="APP_1">%1$s</xliff:g> ukončíte.\n\nPokud se to bude dít neustále, kvůli prodloužení výdrže baterie bude aplikaci možná nutné odinstalovat."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="tablet" msgid="8771690983566539742">"Tablet nemůže normálně šetřit baterii, protože jej aplikace <xliff:g id="APP_0">%1$s</xliff:g> neustále budí.\n\nTento problém můžete vyřešit tím, že aplikaci <xliff:g id="APP_1">%1$s</xliff:g> ukončíte.\n\nPokud se to bude dít neustále, kvůli prodloužení výdrže baterie bude aplikaci možná nutné odinstalovat."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="device" msgid="2854944538238649520">"Zařízení nemůže normálně šetřit baterii, protože jej aplikace <xliff:g id="APP_0">%1$s</xliff:g> neustále budí.\n\nTento problém můžete vyřešit tím, že aplikaci <xliff:g id="APP_1">%1$s</xliff:g> ukončíte.\n\nPokud se to bude dít neustále, kvůli prodloužení výdrže baterie bude aplikaci možná nutné odinstalovat."</string>
    <string name="dialog_stop_ok" msgid="2319777211264004900">"Zastavit aplikaci"</string>
    <string name="dialog_background_check_title" msgid="6936542136153283692">"Vypnout aplikaci včetně používání na pozadí?"</string>
    <string name="dialog_background_check_message" product="default" msgid="4045827746349279563">"Telefon nemůže normálně šetřit baterii, protože jej aplikace <xliff:g id="APP_0">%1$s</xliff:g> neustále budí.\n\nChcete-li problém odstranit, vypněte aplikaci <xliff:g id="APP_1">%1$s</xliff:g> a zabraňte jejímu spuštění na pozadí."</string>
    <string name="dialog_background_check_message" product="tablet" msgid="8348214419901788270">"Tablet nemůže normálně šetřit baterii, protože jej aplikace <xliff:g id="APP_0">%1$s</xliff:g> neustále budí.\n\nChcete-li problém odstranit, vypněte aplikaci <xliff:g id="APP_1">%1$s</xliff:g> a zabraňte jejímu spuštění na pozadí."</string>
    <string name="dialog_background_check_message" product="device" msgid="5847977433118915863">"Zařízení nemůže normálně šetřit baterii, protože jej aplikace <xliff:g id="APP_0">%1$s</xliff:g> neustále budí.\n\nChcete-li problém odstranit, vypněte aplikaci <xliff:g id="APP_1">%1$s</xliff:g> a zabraňte jejímu spuštění na pozadí."</string>
    <string name="dialog_background_check_ok" msgid="412876934682899659">"Vypnout"</string>
    <string name="dialog_location_title" msgid="5888917530725874727">"Vypnout přístup k poloze?"</string>
    <string name="dialog_location_message" product="default" msgid="7774807745601479888">"Telefon nemůže normálně šetřit baterii, protože aplikace <xliff:g id="APP">%1$s</xliff:g> neustále vyžaduje informace o poloze, i když ji zrovna nepoužíváte.\n\nTento problém můžete vyřešit tím, že aplikaci zakážete přístup k poloze."</string>
    <string name="dialog_location_message" product="tablet" msgid="118745801732181618">"Tablet nemůže normálně šetřit baterii, protože aplikace <xliff:g id="APP">%1$s</xliff:g> neustále vyžaduje informace o poloze, i když ji zrovna nepoužíváte.\n\nTento problém můžete vyřešit tím, že aplikaci zakážete přístup k poloze."</string>
    <string name="dialog_location_message" product="device" msgid="6783678153382298295">"Zařízení nemůže normálně šetřit baterii, protože aplikace <xliff:g id="APP">%1$s</xliff:g> neustále vyžaduje informace o poloze, i když ji zrovna nepoužíváte.\n\nTento problém můžete vyřešit tím, že aplikaci zakážete přístup k poloze."</string>
    <string name="dialog_location_ok" msgid="4572391197601313986">"Vypnout"</string>
    <string name="power_screen" msgid="3023346080675904613">"Displej"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Svítilna"</string>
    <string name="power_camera" msgid="4976286950934622605">"Fotoaparát"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="3392999761958982492">"Pohotovostní režim mobilní sítě"</string>
    <string name="power_phone" msgid="5392641106474567277">"Hlasové hovory"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tablet v nečinnosti"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"V nečinnosti"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Různé"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Nadhodnoceno"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"Doba provozu procesoru"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"CPU v popředí"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Zakázat režim spánku"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Wi-Fi je aktivní"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tablet"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefon"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Odeslané pakety – mobilní síť"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Přijaté pakety – mobilní síť"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Modul GSM je aktivní"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Odeslané pakety – Wi‑Fi"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Přijaté pakety – Wi‑Fi"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Zvuk"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Video"</string>
    <string name="usage_type_camera" msgid="8299433109956769757">"Fotoaparát"</string>
    <string name="usage_type_flashlight" msgid="1516392356962208230">"Svítilna"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Doba zapnutí"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Doba bez signálu"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Celková kapacita baterie"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Vypočtená spotřeba energie"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Skutečná spotřeba energie"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Vynutit ukončení"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"O aplikaci"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Nastavení aplikace"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Nastavení obrazovky"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Nastavení Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Nastavení Bluetooth"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Využití baterie hlasovými hovory"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Využití baterie v pohotovostním režimu tabletu"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Využití baterie v pohotovostním režimu telefonu"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Využití baterie jednotkou GSM"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"V oblastech bez pokrytí přepněte do režimu Letadlo"</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Využití baterie svítilnou"</string>
    <string name="battery_desc_camera" msgid="7375389919760613499">"Využití baterie fotoaparátem"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Využití baterie displejem a podsvícením"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Snižte jas displeje nebo interval jeho vypínání"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Využití baterie modulem Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="7776093125855397043">"Pokud síť Wi-Fi nepoužíváte nebo na daném místě není k dispozici, vypněte modul Wi-Fi."</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Využití baterie technologií Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="4565141162650835009">"Vypněte funkci Bluetooth, když ji nepoužíváte."</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Zkuste se připojit k jinému zařízení Bluetooth"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Využití baterie aplikací"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Ukončete aplikaci nebo ji odinstalujte"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Vyberte režim spořiče baterie"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"V aplikaci mohou být k dispozici nastavení ke snížení spotřeby"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Baterie spotřebovaná uživatelem"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Různé využití energie"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"Informace o využití baterie jsou přibližné odhady a neobsahují všechny způsoby využití energie. Pod označením „Různé využití energie“ uvádíme rozdíl mezi vypočtenou přibližnou spotřebou energie a skutečnou spotřebou zjištěnou podle baterie."</string>
    <string name="battery_desc_overcounted" msgid="5481865509489228603">"Nadhodnocení spotřeby energie"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="2690821851327075443">"Využíváno <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="2964359540508103032">"Aktivní <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="6537658662149713585">"Využití obrazovky: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="1135316757755282999">"<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="2093409063297375436">"<xliff:g id="PERCENT">%1$s</xliff:g> z celkové kapacity baterie"</string>
    <string name="battery_detail_since_full_charge" msgid="7515347842046955855">"Přehled od posledního úplného nabití"</string>
    <string name="battery_last_full_charge" msgid="7151251641099019361">"Poslední úplné nabití"</string>
    <string name="battery_full_charge_last" msgid="8892335687734288031">"Přibližná výdrž na plné nabití"</string>
    <string name="battery_footer_summary" msgid="67169726550144016">"Údaje o využití baterie jsou přibližné a mohou se změnit podle způsobu používání"</string>
    <string name="battery_detail_foreground" msgid="3350401514602032183">"Při aktivním používání"</string>
    <string name="battery_detail_background" msgid="1929644393553768999">"Na pozadí"</string>
    <string name="battery_detail_power_usage" msgid="6485766868610469101">"Využití baterie"</string>
    <string name="battery_detail_info_title" msgid="8227822131405620369">"Od úplného nabití"</string>
    <string name="battery_detail_manage_title" msgid="9094314252105828014">"Správa využití baterie"</string>
    <string name="advanced_battery_graph_subtext" msgid="5621073891377915877">"Odhad zbývající výdrže baterie vychází z vašeho používání zařízení"</string>
    <string name="estimated_time_left" msgid="7514194472683370877">"Odhadovaný zbývající čas"</string>
    <string name="estimated_charging_time_left" msgid="5614442409326164691">"Do úplného nabití"</string>
    <string name="estimated_time_description" msgid="8760210909000037089">"Odhad se může měnit podle používání"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> od odpojení"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Při posledním odpojení pro <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Využití baterie celkem"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Aktualizovat"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"OS Android"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Mediaserver"</string>
    <string name="process_dex2oat_label" msgid="2592408651060518226">"Optimalizace aplikací"</string>
    <string name="battery_saver" msgid="8172485772238572153">"Spořič baterie"</string>
    <string name="battery_saver_auto_title" msgid="8368709389419695611">"Zapnout automaticky"</string>
    <string name="battery_saver_auto_no_schedule" msgid="632243833320671052">"Žádný plán"</string>
    <string name="battery_saver_auto_routine" msgid="8076053160450346731">"Na základě vašeho sledu činností"</string>
    <string name="battery_saver_auto_percentage" msgid="9000542338151528905">"Na základě procenta"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3030089882678228374">"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="3653601117764171846">"Zapne se při <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="6000660866895036589">"Nastavení plánu"</string>
    <string name="battery_saver_sticky_title_new" msgid="613272902035943099">"Vypnout při úplném nabití"</string>
    <string name="battery_saver_sticky_description_new" product="default" msgid="6659545534053937371">"Spořič baterie se vypne, až bude telefon na <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="tablet" msgid="6537930800784858686">"Spořič baterie se vypne, až bude tablet na <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="device" msgid="8309483774864505603">"Spořič baterie se vypne, až bude zařízení na <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3795833548145424276) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="1138980155985636295">"Zapnout"</string>
    <string name="battery_saver_master_switch_title" msgid="622539414546588436">"Používat spořič baterie"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Zapnout automaticky"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Nikdy"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="8665950426992057191">"při <xliff:g id="PERCENT">%1$s</xliff:g> baterie"</string>
    <string name="battery_percentage" msgid="723291197508049369">"Procento baterie"</string>
    <string name="battery_percentage_description" msgid="8511658577507384014">"Zobrazovat procento baterie na stavovém řádku"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Statistiky procesů"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Podrobné statistiky běžících procesů"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Využití paměti"</string>
    <string name="process_stats_total_duration" msgid="7417201400853728029">"Za poslední období <xliff:g id="TIMEDURATION">%3$s</xliff:g> bylo využito <xliff:g id="USEDRAM">%1$s</xliff:g> z <xliff:g id="TOTALRAM">%2$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="6522457033380025618">"Za dobu <xliff:g id="TIMEDURATION">%2$s</xliff:g> bylo použito <xliff:g id="PERCENT">%1$s</xliff:g> paměti RAM"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"na pozadí"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"v popředí"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"v mezipaměti"</string>
    <string name="process_stats_os_label" msgid="4813434110442733392">"OS Android"</string>
    <string name="process_stats_os_native" msgid="5322428494231768472">"Nativní"</string>
    <string name="process_stats_os_kernel" msgid="1938523592369780924">"Jádro"</string>
    <string name="process_stats_os_zram" msgid="677138324651671575">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="6432533624875078233">"Mezipaměti"</string>
    <string name="process_stats_ram_use" msgid="976912589127397307">"Využití RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="5398191511030462404">"Využití RAM (pozadí)"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Doba běhu"</string>
    <string name="processes_subtitle" msgid="6827502409379462438">"Procesy"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Služby"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Doba trvání"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Podrobnosti o paměti"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 hodiny"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 hodin"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 hodin"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 den"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Zobrazit systémové aplikace"</string>
    <string name="menu_hide_system" msgid="4106826741703745733">"Skrýt systémové aplikace"</string>
    <string name="menu_show_percentage" msgid="4717204046118199806">"Zobrazit procenta"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Použít USS"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Typ statistik"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"Pozadí"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"Na popředí"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"V mezipaměti"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Hlasový vstup a výstup"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Nastavení hlasového vstupu a výstupu"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Hlasové vyhledávání"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Klávesnice Android"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Nastavení hlasového zadávání"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Hlasové zadávání"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Služby hlasového zadávání"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Úplná aktivace klíčových slov a interakce"</string>
    <string name="voice_recognizer_preference_summary" msgid="669880813593690527">"Jednoduchý převod řeči na text"</string>
    <string name="voice_interaction_security_warning" msgid="6378608263983737325">"Služba hlasového zadávání bude moci neustále monitorovat hlas a ovládat za vás aplikace s aktivovaným hlasovým zadáváním. Služba pochází z <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Chcete použití této služby povolit?"</string>
    <string name="tts_engine_preference_title" msgid="1578826947311494239">"Preferovaný modul"</string>
    <string name="tts_engine_settings_title" msgid="6886964122861384818">"Nastavení modulu"</string>
    <string name="tts_sliders_title" msgid="992059150784095263">"Rychlost řeči a výška hlasu"</string>
    <string name="tts_engine_section_title" msgid="6289240207677024034">"Modul"</string>
    <string name="tts_install_voice_title" msgid="6275828614052514320">"Hlasy"</string>
    <string name="tts_spoken_language" msgid="5542499183472504027">"Mluvený jazyk"</string>
    <string name="tts_install_voices_title" msgid="8808823756936022641">"Instalace hlasů"</string>
    <string name="tts_install_voices_text" msgid="5292606786380069134">"Pokračujte do aplikace <xliff:g id="TTS_APP_NAME">%s</xliff:g> a nainstalujte hlasy"</string>
    <string name="tts_install_voices_open" msgid="667467793360277465">"Do aplikace"</string>
    <string name="tts_install_voices_cancel" msgid="4711492804851107459">"Zrušit"</string>
    <string name="tts_reset" msgid="2661752909256313270">"Obnovit"</string>
    <string name="tts_play" msgid="2628469503798633884">"Přehrát"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"Síť VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Úložiště pověření"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Instalovat z úložiště"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Instalace z karty SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Nainstalovat certifikáty z úložiště"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Nainstalovat certifikáty z karty SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Vymazat pověření"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Odstranit všechny certifikáty"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Důvěryhodná pověření"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Zobrazit důvěryhodné certifikáty CA"</string>
    <string name="user_credentials" msgid="3719013347787187083">"Identifikační údaje uživatele"</string>
    <string name="user_credentials_summary" msgid="7271228342106080167">"Zobrazení a úprava uložených identifikačních údajů"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Rozšířené nastavení"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Typ úložiště"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Hardwarové"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Pouze software"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Pro tohoto uživatele jsou identifikační údaje nedostupné."</string>
    <string name="credential_for_vpn_and_apps" msgid="4168197158768443365">"Nainstalováno pro síť VPN a aplikace"</string>
    <string name="credential_for_wifi" msgid="6228425986551591864">"Nainstalování pro síť Wi-Fi"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Odstranit veškerý obsah?"</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Úložiště pověření je vymazáno."</string>
    <string name="credentials_not_erased" msgid="7685932772284216097">"Úložiště pověření nelze smazat."</string>
    <string name="usage_access_title" msgid="332333405495457839">"Přístup k dat. o používání"</string>
    <string name="emergency_tone_title" msgid="254495218194925271">"Signál nouzového vytáčení"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Nastavit chování při tísňovém volání"</string>
    <string name="privacy_settings_title" msgid="2978878794187459190">"Záloha"</string>
    <string name="backup_summary_state_on" msgid="6407084627816231202">"Zapnuto"</string>
    <string name="backup_summary_state_off" msgid="7388321532624105594">"Vypnuto"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Zálohování a obnovení"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Osobní údaje"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Zálohování mých dat"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Zálohovat data aplikací, hesla sítí Wi-Fi a další nastavení na serverech Google"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Záložní účet"</string>
    <string name="backup_data_management_title" msgid="4059093462647090064">"Spravovat účet k zálohování"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Zahrnout data aplikací"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Automatické obnovení"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Při přeinstalaci aplikace obnovit zálohovaná nastavení a další data"</string>
    <string name="backup_inactive_title" msgid="685838037986644604">"Služba zálohování není aktivní"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Aktuálně nejsou zálohovaná data ukládána do žádného účtu."</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Chcete přestat zálohovat hesla sítí Wi-Fi, záložky, další nastavení, data aplikací a vymazat všechny kopie ze serverů Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="694766389396659626">"Zastavit zálohování dat zařízení (jako jsou hesla sítí Wi-Fi a historie volání) a dat aplikací (jako jsou nastavení a soubory uložené aplikacemi) a vymazat všechny kopie na vzdálených serverech?"</string>
    <string name="fullbackup_data_summary" msgid="960850365007767734">"Automaticky vzdáleně zálohujte data zařízení (jako jsou hesla sítí Wi-Fi a historie volání) a data aplikací (jako jsou nastavení a soubory uložené aplikacemi).\n\nKdyž zapnete automatické zálohování, data zařízení a aplikací se budou pravidelně ukládat do vzdáleného úložiště. Data aplikací mohou zahrnovat data, která uložila aplikace (v závislosti na nastavení vývojáře), včetně potenciálně citlivých dat, jako jsou kontakty, zprávy a fotky."</string>
    <string name="device_admin_settings_title" msgid="4960761799560705902">"Nastavení administrátora zařízení"</string>
    <string name="active_device_admin_msg" msgid="578748451637360192">"Aplikace pro správu zařízení"</string>
    <string name="remove_device_admin" msgid="9207368982033308173">"Deaktivovat tuto aplikaci pro správu zařízení"</string>
    <string name="uninstall_device_admin" msgid="271120195128542165">"Odinstalovat aplikaci"</string>
    <string name="remove_and_uninstall_device_admin" msgid="3837625952436169878">"Deaktivovat a odinstalovat"</string>
    <string name="select_device_admin_msg" msgid="7347389359013278077">"Aplikace pro správu zařízení"</string>
    <string name="no_device_admins" msgid="4846602835339095768">"Nejsou k dispozici žádné aplikace pro správu zařízení"</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Osobní"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Pracovní"</string>
    <string name="sms_access_restriction_enabled" msgid="7054488078710530278">"Omezit přístup k SMS a seznamu hovorů"</string>
    <string name="sms_access_restriction_enabled_summary" msgid="6851339654677842328">"Přístup k SMS a seznamu hovorů mají jen výchozí aplikace na telefonování a odesílání zpráv"</string>
    <string name="device_identifier_access_restrictions_title" msgid="263947581571420743">"Deaktivace omezení identifikátoru zařízení"</string>
    <string name="device_identifier_access_restrictions_summary" msgid="1716838570236517731">"Deaktivace nového omezení přístupu k identifikátorům zařízení"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Nejsou k dispozici žádní zástupci důvěryhodnosti."</string>
    <string name="add_device_admin_msg" msgid="1501847129819382149">"Aktivovat aplikaci pro správu zařízení?"</string>
    <string name="add_device_admin" msgid="4192055385312215731">"Aktivovat tuto aplikaci pro správu zařízení"</string>
    <string name="device_admin_add_title" msgid="3140663753671809044">"Administrátor zařízení"</string>
    <string name="device_admin_warning" msgid="7482834776510188134">"Aktivace této aplikace pro správu aplikaci <xliff:g id="APP_NAME">%1$s</xliff:g> umožní provádět následující operace:"</string>
    <string name="device_admin_status" msgid="7234814785374977990">"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="6249331160676175009">"Aktivovat správce profilů?"</string>
    <string name="adding_profile_owner_warning" msgid="1354474524852805802">"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="7712694507069054530">"Ostatní možnosti váš administrátor zakázal"</string>
    <string name="admin_more_details" msgid="7901420667346456102">"Další podrobnosti"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Protokol oznámení"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Tón vyzvánění a vibrace"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Podrobnosti sítě"</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Synchronizace zapnuta"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Synchronizace deaktivována"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Probíhá synchronizace..."</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Chyba synchronizace."</string>
    <string name="sync_failed" msgid="1696499856374109647">"Synchronizace se nezdařila"</string>
    <string name="sync_active" msgid="8476943765960863040">"Synchronizace je aktivní"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Synchronizace"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Nastaly potíže se synchronizací. Služba bude brzy obnovena."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Přidat účet"</string>
    <string name="managed_profile_not_available_label" msgid="852263300911325904">"Pracovní profil zatím není k dispozici"</string>
    <string name="work_mode_label" msgid="7157582467956920750">"Pracovní profil"</string>
    <string name="work_mode_on_summary" msgid="3628349169847990263">"Spravováno vaší organizací"</string>
    <string name="work_mode_off_summary" msgid="2657138190560082508">"Aplikace a oznámení jsou vypnuta"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Odstranit pracovní profil"</string>
    <string name="background_data" msgid="5779592891375473817">"Data na pozadí"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Aplikace mohou kdykoli synchronizovat, odesílat a přijímat data."</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Deaktivovat data na pozadí?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Deaktivace přenosu dat na pozadí šetří baterii a snižuje objem přenesených dat. Některé aplikace mohou přesto datové připojení na pozadí používat."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Autom. synch. data aplikací"</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Synchronizace je zapnuta"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Synchronizace vypnuta"</string>
    <string name="sync_error" msgid="5060969083117872149">"Chyba synchronizace"</string>
    <string name="last_synced" msgid="4242919465367022234">"Poslední synchronizace <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Probíhá synchronizace..."</string>
    <string name="settings_backup" msgid="2274732978260797031">"Nastavení zálohování"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Zálohovat moje nastavení"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Synchronizovat"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Zrušit synchronizaci"</string>
    <string name="sync_one_time_sync" msgid="3733796114909082260">"Klepnutím synchronizujete (poslední synchronizace proběhla <xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>)"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Kalendář"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Kontakty"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Vítá vás aplikace Google Sync."</font>" \nNový pohled společnosti Google na synchronizaci dat vám poskytuje přístup ke kontaktům, schůzkám a dalším informacím, ať jste kdekoli."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Nastavení synchronizace aplikací"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Data a synchronizace"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Změnit heslo"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Nastavení účtu"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Odebrat účet"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Přidat účet"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Chcete odebrat účet?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Odebráním účtu smažete z tabletu také všechny zprávy, kontakty a další data tohoto účtu."</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Odebráním účtu smažete z telefonu také všechny zprávy, kontakty a další data tohoto účtu."</string>
    <string name="really_remove_account_message" product="device" msgid="7507474724882080166">"Odebráním účtu smažete ze zařízení také všechny jeho zprávy, kontakty a další data."</string>
    <string name="remove_account_failed" msgid="3901397272647112455">"Administrátor tuto změnu zakázal"</string>
    <string name="cant_sync_dialog_title" msgid="2777238588398046285">"Nelze ručně synchronizovat"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Synchronizace této položky je aktuálně deaktivována. Chcete-li nastavení změnit, dočasně zapněte přenos dat na pozadí a automatickou synchronizaci."</string>
    <string name="enter_password" msgid="8035706727471334122">"Chcete-li spustit Android, zadejte heslo"</string>
    <string name="enter_pin" msgid="5305333588093263790">"Chcete-li spustit Android, zadejte PIN"</string>
    <string name="enter_pattern" msgid="4187435713036808566">"Chcete-li spustit Android, nakreslete gesto"</string>
    <string name="cryptkeeper_wrong_pattern" msgid="8423835922362956999">"Nesprávné gesto"</string>
    <string name="cryptkeeper_wrong_password" msgid="5200857195368904047">"Nesprávné heslo"</string>
    <string name="cryptkeeper_wrong_pin" msgid="755720788765259382">"Nesprávný kód PIN"</string>
    <string name="checking_decryption" msgid="8287458611802609493">"Kontrola…"</string>
    <string name="starting_android" msgid="4001324195902252681">"Spouštění systému Android…"</string>
    <string name="delete" msgid="4219243412325163003">"Smazat"</string>
    <string name="misc_files" msgid="6720680815969643497">"Různé soubory"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"vybráno: <xliff:g id="NUMBER">%1$d</xliff:g> z <xliff:g id="TOTAL">%2$d</xliff:g>"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> z <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Vybrat vše"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Využití dat"</string>
    <string name="data_usage_app_summary_title" msgid="5571051159374290375">"Mobilní data &amp; Wi‑Fi"</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"Účtování dat operátora se může lišit od údajů zařízení."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Využití aplikací"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"O APLIKACI"</string>
    <string name="data_usage_cellular_data" msgid="9168928285122125137">"Mobilní data"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Zadejte limit dat"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Cyklus počítání dat"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Využití aplikací"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Datový roaming"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Omezení přenosů na pozadí"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Povolit data na pozadí"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Oddělit datové přenosy 4G"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Zobrazit využití Wi‑Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Skrýt použití Wi‑Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Zobrazit využití ethernetu"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Skrýt použití ethernetu"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Omezení sítě"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Automatická synchronizace dat"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"SIM karty"</string>
    <string name="data_usage_cellular_data_summary" msgid="8413357481361268285">"Pozastaveno při limitu"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Autom. synchronizovat data"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Autom. synch. osobní data"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Autom. synch. pracovní data"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Změnit cyklus..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Den v měsíci, kdy se má obnovit počítání datových přenosů:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"V tomto období nevyužily datové připojení žádné aplikace."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Na popředí"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Na pozadí"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"omezeno"</string>
    <string name="data_usage_disable_mobile" msgid="8656552431969276305">"Vypnout mobilní data?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Nastavit limit mobilních dat"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Nastavit limit dat 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Nastavit limit dat 2G–3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Datový limit Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="454140350007299045">"Mobil"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G a 3G"</string>
    <string name="data_usage_list_mobile" msgid="5588685410495019866">"Mobilní"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Žádné"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"Mobilní datové přenosy"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"Datové přenosy 2G a 3G"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"Datové přenosy 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="1523331545457578362">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Popředí:"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"Pozadí:"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Nastavení aplikace"</string>
    <string name="data_usage_app_restrict_background" msgid="7359227831562303223">"Data na pozadí"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="5853552187570622572">"Povolit využití mobilních dat na pozadí"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"Data na pozadí u aplikace omezíte nastavením limitu mob. dat."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Omezit přenosy na pozadí?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="1466689968707308512">"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="55012417305745608">"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="2438617846762244389">"Zapnout automatickou synchronizaci dat?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"Změny, které v rámci svých účtů provedete na webu, se automaticky zkopírují do tabletu.\n\nNěkteré účty také automaticky zkopírují změny provedené v tabletu na web. Tímto způsobem funguje například účet Google."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="8651376294887142858">"Změny, které v rámci svých účtů provedete na webu, se automaticky zkopírují do telefonu.\n\nNěkteré účty také automaticky zkopírují změny provedené v telefonu na web. Tímto způsobem funguje například účet Google."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Vypnout automatickou synchronizaci dat?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4025938250775413864">"Toto nastavení šetří využití dat a baterii. Nejnovější informace však bude třeba získávat pomocí ruční synchronizace účtu. Rovněž nebudete dostávat oznámení o dostupných aktualizacích."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Datum obnovení cyklu sledování přenesených dat"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Datum v každém měsíci:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Nastavit"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Nastavit upozornění na využití dat"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Nastavení limitu datových přenosů"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Omezení spotřeby dat"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="4983487893343645667">"Až tablet dosáhne stanoveného limitu, datové připojení k mobilní síti bude vypnuto.\n\nProtože se přenesená data měří pomocí tabletu a operátor je může účtovat odlišně, je vhodné nastavit nízký limit."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3926320594049434225">"Až telefon dosáhne stanoveného limitu, datové připojení k mobilní síti bude vypnuto.\n\nProtože se přenesená data měří pomocí telefonu a operátor je může účtovat odlišně, je vhodné nastavit nízký limit."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Omezit přenosy na pozadí?"</string>
    <string name="data_usage_restrict_background" msgid="434093644726734586">"Pokud omezíte využití mobilních dat na pozadí, některé aplikace a služby nebudou fungovat, dokud se nepřipojíte k síti Wi-Fi."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="7096707497743363380">"Pokud omezíte využití mobilních dat na pozadí, některé aplikace a služby nebudou fungovat, dokud se nepřipojíte k síti Wi-Fi.\n\nToto nastavení ovlivní všechny uživatele tohoto tabletu."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="7910798414964288424">"Pokud omezíte využití mobilních dat na pozadí, některé aplikace a služby nebudou fungovat, dokud se nepřipojíte k síti Wi-Fi.\n\nToto nastavení ovlivní všechny uživatele tohoto telefonu."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"oznámení"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039"><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="614263770923231598">"Odebrané aplikace"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Odebrané aplikace a odebraní uživatelé"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"Přijato <xliff:g id="RECEIVED">%1$s</xliff:g>, odesláno <xliff:g id="SENT">%2$s</xliff:g>"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g>: využito asi <xliff:g id="TOTAL">%1$s</xliff:g>."</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="1925687342154538972">"<xliff:g id="RANGE">%2$s</xliff:g>: podle měření tabletu využito asi <xliff:g id="TOTAL">%1$s</xliff:g>. Operátor může využití dat účtovat odlišně."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="5063981061103812900">"<xliff:g id="RANGE">%2$s</xliff:g>: podle měření telefonu využito asi <xliff:g id="TOTAL">%1$s</xliff:g>. Operátor může využití dat účtovat odlišně."</string>
    <string name="data_usage_metered_title" msgid="7383175371006596441">"Omezení sítě"</string>
    <string name="data_usage_metered_body" msgid="7655851702771342507">"Jsou-li omezena data na pozadí, budeme s měřenými sítěmi zacházet stejně jako s mobilními. Před zahájením stahování velkých souborů pomocí těchto sítí mohou aplikace zobrazit upozornění."</string>
    <string name="data_usage_metered_mobile" msgid="5423305619126978393">"Mobilní sítě"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"Měřené sítě Wi-Fi"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Chcete-li vybrat měřené sítě, zapněte připojení Wi-Fi."</string>
    <string name="data_usage_metered_auto" msgid="1262028400911918865">"Automaticky"</string>
    <string name="data_usage_metered_yes" msgid="9217539611385225894">"Měřená"</string>
    <string name="data_usage_metered_no" msgid="4025232961929071789">"Neměřená"</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Účtování dat operátora se může lišit od údajů zařízení."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Tísňové volání"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Zpět k hovoru"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Název"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Typ"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Adresa serveru"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"Šifrování PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"Tajný klíč L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"Identifikátor protokolu IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Předsdílený klíč IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"Uživatelský certifikát IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"Certifikát CA protokolu IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Certifikát serveru IPSec"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Zobrazit rozšířené možnosti"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Domény vyhledávání DNS"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"Servery DNS (např. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Přesměrovávací trasy (např. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Uživatelské jméno"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Heslo"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Uložit údaje o účtu"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(nepoužíváno)"</string>
    <string name="vpn_no_ca_cert" msgid="8776029412793353361">"(neověřovat server)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(přijato ze serveru)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="7574518311224455825">"Tento typ sítě VPN nemůže zůstat trvale připojen"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="477304620899799383">"Trvalé sítě VPN podporují pouze číselné adresy serverů"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="2226648961940273294">"U trvalé sítě VPN musí být zadán server DNS"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3551394495620249972">"Adresy serverů DNS trvalých sítí VPN musejí být číselné"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="5959352052515258208">"Zadané údaje trvalou síť VPN nepodporují"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Zrušit"</string>
    <string name="vpn_done" msgid="8678655203910995914">"Zavřít"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Uložit"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Připojit"</string>
    <string name="vpn_replace" msgid="5442836256121957861">"Nahradit"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Upravit profil VPN"</string>
    <string name="vpn_forget" msgid="3684651372749415446">"Zapomenout"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Připojit k profilu <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="3743970132487505659">"Odpojit tuto síť VPN?"</string>
    <string name="vpn_disconnect" msgid="7426570492642111171">"Odpojit"</string>
    <string name="vpn_version" msgid="1939804054179766249">"Verze <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="2232239391189465752">"Zapomenout VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="2963898301277610248">"Nahradit stávající síť VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="4009987321156037267">"Nastavit trvalou síť VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="7144543717673197102">"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="798121133114824006">"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="3011818750025879902">"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="5611635724578812860">"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="2363136869284273872">"Zapnout"</string>
    <string name="vpn_cant_connect_title" msgid="4517706987875907511">"Síť <xliff:g id="VPN_NAME">%1$s</xliff:g> se nedokáže připojit"</string>
    <string name="vpn_cant_connect_message" msgid="1352832123114214283">"Tato aplikace trvalou síť VPN nepodporuje"</string>
    <string name="vpn_title" msgid="6317731879966640551">"Síť VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Přidat profil VPN"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Upravit profil"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Smazat profil"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Trvalá síť VPN"</string>
    <string name="vpn_no_vpns_added" msgid="5002741367858707244">"Nebyly přidány žádné sítě VPN"</string>
    <string name="vpn_always_on_summary" msgid="2821344524094363617">"Zajistit trvalé připojení k síti VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="592304911378771510">"Aplikace tuto funkci nepodporuje"</string>
    <string name="vpn_always_on_summary_active" msgid="8800736191241875669">"Trvalá síť VPN je aktivní"</string>
    <string name="vpn_require_connection" msgid="8388183166574269666">"Blokovat připojení bez VPN"</string>
    <string name="vpn_require_connection_title" msgid="159053539340576331">"Vyžadovat připojení VPN?"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Vyberte profil VPN, ke kterému chcete zůstat trvale připojeni. Síťový provoz bude povolen pouze v případě, že budete připojeni k této síti VPN."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Žádná"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Trvalá síť VPN vyžaduje IP adresu pro server i DNS."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Připojení k síti není k dispozici. Zkuste to prosím znovu později."</string>
    <string name="vpn_disconnected" msgid="280531508768927471">"Odpojeno od sítě VPN"</string>
    <string name="vpn_disconnected_summary" msgid="3082851661207900606">"Žádné"</string>
    <string name="vpn_missing_cert" msgid="5357192202207234745">"Chybí certifikát. Zkuste upravit profil."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Systém"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Uživatel"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Zakázat"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Povolit"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Odstranit"</string>
    <string name="trusted_credentials_trust_label" msgid="8003264222650785429">"Důvěřovat"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Povolit certifikát CA systému?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Zakázat certifikát CA systému?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Natrvalo odstranit uživatelský certifikát CA?"</string>
    <string name="credential_contains" msgid="3984922924723974084">"Obsah záznamu:"</string>
    <string name="one_userkey" msgid="6034020579534914349">"jeden klíč uživatele"</string>
    <string name="one_usercrt" msgid="2150319011101639509">"jeden certifikát uživatele"</string>
    <string name="one_cacrt" msgid="6844397037970164809">"jeden certifikát CA"</string>
    <string name="n_cacrts" msgid="5979300323482053820">"certifikáty CA (%d)"</string>
    <string name="user_credential_title" msgid="1954061209643070652">"Podrobnosti o identifikačních údajích"</string>
    <string name="user_credential_removed" msgid="6514189495799401838">"Odstraněné identifikační údaje: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="3729607560420971841">"Nejsou nainstalovány žádné identifikační údaje uživatele"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Kontrola pravopisu"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="4114555511355171248">"Kontrola pravopisu pro práci"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Sem zadejte aktuální heslo pro úplné zálohy."</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Sem zadejte nové heslo pro úplné zálohy."</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Sem znovu zadejte nové heslo pro úplné zálohy."</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Nastavit heslo pro zálohy"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Zrušit"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Další aktualizace systému"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Síť může být monitorována"</string>
    <string name="done_button" msgid="1991471253042622230">"Hotovo"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="7145092748045794650">
      <item quantity="few">Označit certifikáty jako důvěryhodné nebo je odstranit</item>
      <item quantity="many">Označit certifikáty jako důvěryhodné nebo je odstranit</item>
      <item quantity="other">Označit certifikáty jako důvěryhodné nebo je odstranit</item>
      <item quantity="one">Označit certifikát jako důvěryhodný nebo jej odstranit</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message_device_owner" formatted="false" msgid="1489335297837656666">
      <item quantity="few">Doména <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> do vašeho zařízení nainstalovala certifikační autority, které umožňují sledování aktivity zařízení na síti, včetně e-mailů, aplikací a zabezpečených webů.\n\nDalší informace o těchto certifikátech vám poskytne administrátor.</item>
      <item quantity="many">Doména <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> do vašeho zařízení nainstalovala certifikační autority, které umožňují sledování aktivity zařízení na síti, včetně e-mailů, aplikací a zabezpečených webů.\n\nDalší informace o těchto certifikátech vám poskytne administrátor.</item>
      <item quantity="other">Doména <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> do vašeho zařízení nainstalovala certifikační autority, které umožňují sledování aktivity zařízení na síti, včetně e-mailů, aplikací a zabezpečených webů.\n\nDalší informace o těchto certifikátech vám poskytne administrátor.</item>
      <item quantity="one">Doména <xliff:g id="MANAGING_DOMAIN_0">%s</xliff:g> do vašeho zařízení nainstalovala certifikační autoritu, která umožňuje sledování aktivity zařízení na síti, včetně e-mailů, aplikací a zabezpečených webů.\n\nDalší informace o tomto certifikátu vám poskytne administrátor.</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message" formatted="false" msgid="30645643499556573">
      <item quantity="few">Doména <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> pro váš pracovní profil nainstalovala certifikační autority, které mohou umožnit monitorování aktivity v pracovní síti, včetně odesílání e-mailů, aplikací a zabezpečených webů.\n\nDalší informace o těchto certifikátech vám poskytne administrátor.</item>
      <item quantity="many">Doména <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> pro váš pracovní profil nainstalovala certifikační autority, které mohou umožnit monitorování aktivity v pracovní síti, včetně odesílání e-mailů, aplikací a zabezpečených webů.\n\nDalší informace o těchto certifikátech vám poskytne administrátor.</item>
      <item quantity="other">Doména <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> pro váš pracovní profil nainstalovala certifikační autority, které mohou umožnit monitorování aktivity v pracovní síti, včetně odesílání e-mailů, aplikací a zabezpečených webů.\n\nDalší informace o těchto certifikátech vám poskytne administrátor.</item>
      <item quantity="one">Doména <xliff:g id="MANAGING_DOMAIN_0">%s</xliff:g> pro váš pracovní profil nainstalovala certifikační autoritu, která může umožnit monitorování aktivity v pracovní síti, včetně odesílání e-mailů, aplikací a zabezpečených webů.\n\nDalší informace o tomto certifikátu vám poskytne administrátor.</item>
    </plurals>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"Vaše aktivita v síti, včetně e-mailů, aplikací a zabezpečených webových stránek může být monitorována třetí stranou.\n\nUmožňují to důvěryhodné identifikační údaje nainstalované ve vašem zařízení."</string>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="2426799352517325228">
      <item quantity="few">Zkontrolovat certifikáty</item>
      <item quantity="many">Zkontrolovat certifikáty</item>
      <item quantity="other">Zkontrolovat certifikáty</item>
      <item quantity="one">Zkontrolovat certifikát</item>
    </plurals>
    <string name="user_settings_title" msgid="3493908927709169019">"Více uživatelů"</string>
    <string name="user_settings_footer_text" product="device" msgid="5947601460660791129">"Chcete-li zařízení sdílet, přidejte nové uživatele. Každý uživatel má v zařízení vlastní prostor na plochy, účty, aplikace, nastavení apod."</string>
    <string name="user_settings_footer_text" product="tablet" msgid="2153761434649733502">"Chcete-li tablet sdílet, přidejte nové uživatele. Každý uživatel má v tabletu vlastní prostor na plochy, účty, aplikace, nastavení apod."</string>
    <string name="user_settings_footer_text" product="default" msgid="2844602828189838075">"Chcete-li telefon sdílet, přidejte nové uživatele. Každý uživatel má v telefonu vlastní prostor na plochy, účty, aplikace, nastavení apod."</string>
    <string name="user_list_title" msgid="7937158411137563543">"Uživatelé a profily"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Přidat uživatele nebo profil"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Přidat uživatele"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Omezený profil"</string>
    <string name="user_need_lock_message" msgid="5879715064416886811">"Před vytvořením omezeného profilu je nutné nejprve nastavit zámek obrazovky k ochraně aplikací a dat."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Nastavit zámek"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Není nastaveno"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Není nastaveno – omezený profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="1659125858619760573">"Nenastaveno – pracovní profil"</string>
    <string name="user_admin" msgid="993402590002400782">"Administrátor"</string>
    <string name="user_you" msgid="1639158809315025986">"Vy (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Přezdívka"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Přidat"</string>
    <string name="user_add_max_count" msgid="5405885348463433157">"Maximální počet přidávaných uživatelů: <xliff:g id="USER_COUNT">%1$d</xliff:g>"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Uživatelé mají své vlastní aplikace a obsah."</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Můžete omezit přístup k aplikacím a obsahu ze svého účtu"</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Uživatel"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Omezený profil"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"Přidat nového uživatele?"</string>
    <string name="user_add_user_message_long" msgid="6768718238082929201">"Vytvořením dalších uživatelů můžete toto zařízení sdílet s jinými lidmi. Každý uživatel má svůj prostor, který si může přizpůsobit instalací aplikací, přidáním tapety apod. Uživatelé také mohou upravit nastavení zařízení (např. Wi-Fi), která ovlivní všechny uživatele.\n\nKaždý nově přidaný uživatel si musí nastavit vlastní prostor.\n\nKaždý uživatel může aktualizovat aplikace všech ostatních uživatelů."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Když přidáte nového uživatele, musí si nastavit vlastní prostor.\n\nJakýkoli uživatel může aktualizovat aplikace všech ostatních uživatelů."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Nastavit uživatele?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"Ujistěte se, že je uživatel k dispozici a může si v zařízení nastavit svůj prostor"</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Nastavit profil?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Nastavit"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Teď ne"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="7153048188252553320">"Uživatele smí spravovat pouze vlastník tabletu."</string>
    <string name="user_cannot_manage_message" product="default" msgid="959315813089950649">"Uživatele smí spravovat pouze vlastník telefonu."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Pomocí omezených profilů nelze přidávat účty."</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Smazat <xliff:g id="USER_NAME">%1$s</xliff:g> ze zařízení"</string>
    <string name="user_lockscreen_settings" msgid="4965661345247084878">"Nastavení obrazovky uzamčení"</string>
    <string name="user_add_on_lockscreen_menu" msgid="9072312646546364619">"Přidání uživatele z obrazovky uzamčení"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Nový uživatel"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Nový profil"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Chcete se smazat?"</string>
    <string name="user_confirm_remove_title" msgid="8068422695175097315">"Smazat tohoto uživatele?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Odstranit tento profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"Odstranit pracovní profil?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="2391372805233812410">"Přijdete o místo a data v tomto tabletu. Tuto akci nelze vrátit zpět."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="7943645442479360048">"Přijdete o místo a data v tomto telefonu. Tuto akci nelze vrátit zpět."</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"Budou smazány všechny aplikace a data."</string>
    <string name="work_profile_confirm_remove_message" msgid="323856589749078140">"Budete-li pokračovat, budou smazány všechny aplikace a data z tohoto profilu."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"Budou smazány všechny aplikace a data."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Přidávání nového uživatele…"</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Smazat uživatele"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Smazat"</string>
    <string name="user_guest" msgid="8475274842845401871">"Host"</string>
    <string name="user_exit_guest_title" msgid="5613997155527410675">"Odstranit hosta"</string>
    <string name="user_exit_guest_confirm_title" msgid="3405527634738147409">"Odstranit hosta?"</string>
    <string name="user_exit_guest_confirm_message" msgid="2194459201944413257">"Veškeré aplikace a data v této relaci budou vymazána."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Odstranit"</string>
    <string name="user_enable_calling" msgid="5128605672081602348">"Zapnout telefonní hovory"</string>
    <string name="user_enable_calling_sms" msgid="9172507088023097063">"Zapnout telefonní hovory a SMS"</string>
    <string name="user_remove_user" msgid="3612979309028881318">"Smazání uživatele"</string>
    <string name="user_enable_calling_confirm_title" msgid="4315789475268695378">"Zapnout telefonní hovory?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"S tímto uživatelem bude sdílena historie hovorů."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="7243308401401932681">"Zapnout telefonní hovory a SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="4025082715546544967">"S tímto uživatelem bude sdílena historie hovorů a SMS."</string>
    <string name="emergency_info_title" msgid="208607506217060337">"Nouzové informace"</string>
    <string name="emergency_info_summary" msgid="5062945162967838521">"Informace a kontakty uživatele <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Povolit aplikace a obsah"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Aplikace s omezením"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Rozbalit nastavení aplikace"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Platby přiložením telefonu"</string>
    <string name="nfc_payment_how_it_works" msgid="3028822263837896720">"Jak to funguje"</string>
    <string name="nfc_payment_no_apps" msgid="5477904979148086424">"Plaťte v obchodech telefonem"</string>
    <string name="nfc_payment_default" msgid="8648420259219150395">"Výchozí platební aplikace"</string>
    <string name="nfc_payment_default_not_set" msgid="7485060884228447765">"Nenastaveno"</string>
    <string name="nfc_payment_app_and_desc" msgid="7942415346564794258">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="3234730182120288495">"Použít výchozí"</string>
    <string name="nfc_payment_favor_default" msgid="5743781166099608372">"Vždy"</string>
    <string name="nfc_payment_favor_open" msgid="1923314062109977944">"Kromě případů, kdy je spuštěna jiná platební aplikace"</string>
    <string name="nfc_payment_pay_with" msgid="7524904024378144072">"Aplikace pro platby přiložením telefonu:"</string>
    <string name="nfc_how_it_works_title" msgid="1984068457698797207">"Platba na terminálu"</string>
    <string name="nfc_how_it_works_content" msgid="4749007806393224934">"Nastavte platební aplikaci. Poté jen přidržte telefon zadní stranou u terminálu se symbolem bezkontaktních plateb."</string>
    <string name="nfc_how_it_works_got_it" msgid="259653300203217402">"Rozumím"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Další..."</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Nastavit jako předvolbu?"</string>
    <string name="nfc_payment_set_default" msgid="8532426406310833489">"Chcete při platbě přiložením telefonu vždy používat aplikaci <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="6993301165940432743">"Chcete při platbě přiložením telefonu namísto aplikace <xliff:g id="APP_0">%1$s</xliff:g> vždy používat aplikaci <xliff:g id="APP_1">%2$s</xliff:g>?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Omezení"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Odebrat omezení"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Změnit PIN"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Zobrazovat oznámení"</string>
    <string name="help_label" msgid="6886837949306318591">"Nápověda a zpětná vazba"</string>
    <string name="support_summary" msgid="2705726826263742491">"Články nápovědy, telefon a chat, začínáme"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Účet pro obsah"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID fotografie"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Extrémní ohrožení"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Přijímat upozornění na extrémní ohrožení života a majetku"</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Závažná ohrožení"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Přijímat upozornění na závažná ohrožení života a majetku"</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"Upozornění AMBER"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Přijímat bulletiny o únosech dětí"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Opakovat"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Aktivovat Správce hovorů"</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Povolí této službě spravovat způsob uskutečňování hovorů."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Správce hovorů"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="4124461751977706019">"Výstražné zprávy"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Síťoví operátoři"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Názvy přístupových bodů"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="2544026384901010606">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="480304128966864221">"Rozšířené volání"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="6839553611093179243">"Volání přes síť 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="4156658595226379286">"Používat ke zlepšení hlasové a další komunikace služby LTE (doporučeno)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="6145184730437907078">"Používat ke zlepšení hlasové a další komunikace služby 4G (doporučeno)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Preferovaný typ sítě"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (doporučeno)"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"Pracovní SIM karta"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Přístup k aplikacím a obsahu"</string>
    <string name="user_rename" msgid="8523499513614655279">"PŘEJMENOVAT"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Nastavit omezení aplikací"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Řízeno aplikací <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Tato aplikace má přístup k vašim účtům"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="6968697624437267294">"Tato aplikace má přístup k vašim účtům. Řízeno aplikací <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"Sítě Wi‑Fi a mobilní sítě"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Povolit úpravu nastavení sítí Wi-Fi a mobilních sítí"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Povolit úpravy párování a nastavení zařízení Bluetooth"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Povolit výměnu dat, když se toto zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g> dotkne jiného zařízení s funkcí NFC."</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Povolit výměnu dat, pokud se tablet dotkne jiného zařízení"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Povolit výměnu dat, pokud se telefon dotkne jiného zařízení"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Poloha"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Povolit aplikaci používat informace o vaší poloze"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Zpět"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Další"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Dokončit"</string>
    <string name="user_image_take_photo" msgid="4038201220173969126">"Vyfotit"</string>
    <string name="user_image_choose_photo" msgid="7643300431215339631">"Zvolit obrázek"</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Vybrat fotografii"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"SIM karty"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"SIM karty"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<xliff:g id="SIM_NAME">%1$s</xliff:g> – <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7900721153345139783">"Došlo k výměně SIM karet"</string>
    <string name="sim_cards_changed_message_summary" msgid="8258058274989383204">"Klepnutím nastavte aktivity"</string>
    <string name="sim_cellular_data_unavailable" msgid="9109302537004566098">"Mobilní data nejsou k dispozici"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="5416535001368135327">"Klepnutím vyberte datovou SIM kartu"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Vždy používat pro hovory"</string>
    <string name="select_sim_for_data" msgid="2366081042162853044">"Vyberte SIM kartu pro data"</string>
    <string name="select_sim_for_sms" msgid="6232060107120265044">"Vyberte SIM kartu pro SMS"</string>
    <string name="data_switch_started" msgid="2040761479817166311">"Přepínání datových SIM karet, tato operace může chvíli trvat..."</string>
    <string name="select_sim_for_calls" msgid="3503094771801109334">"Volat pomocí"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Vyberte SIM kartu"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"SIM karta <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"Prázdná SIM"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Název SIM karty"</string>
    <string name="sim_name_hint" msgid="7038643345238968930">"Zadejte název SIM karty"</string>
    <string name="sim_editor_title" msgid="4034301817366627870">"Slot pro SIM kartu %1$d"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Operátor"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Číslo"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"Barva SIM karty"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"Vybrat SIM kartu"</string>
    <string name="color_orange" msgid="4417567658855022517">"Oranžová"</string>
    <string name="color_purple" msgid="3888532466427762504">"Nachová"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"Nejsou vloženy žádné SIM karty"</string>
    <string name="sim_status_title" msgid="6744870675182447160">"Stav SIM karty"</string>
    <string name="sim_status_title_sim_slot" msgid="5725659316463979194">"Stav SIM karty (slot na SIM kartu %1$d)"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Volat zpět z výchozí SIM karty"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"SIM karta pro odchozí hovory"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Další nastavení hovorů"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"Preferované zatížení sítě"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Zakázat vysílání názvu sítě"</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"Zakázáním vysílání názvu sítě zabráníte třetím stranám v zobrazení informací o vaší síti."</string>
    <string name="preferred_network_offload_popup" msgid="2252915199889604600">"Zakázáním vysílání názvu sítě zabráníte automatickému připojování ke skrytým sítím."</string>
    <string name="sim_signal_strength" msgid="9144010043784767984">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="6272913297433198340">"SIM karty byly změněny."</string>
    <string name="sim_notification_summary" msgid="8858043655706669772">"Klepnutím přejděte do Nastavení"</string>
    <string name="sim_pref_divider" msgid="6778907671867621874">"Preferovaná SIM karta"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="7941299533514115976">"Pokaždé se zeptat"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Vyžadován výběr"</string>
    <string name="sim_selection_channel_title" msgid="2760909074892782589">"Výběr SIM karty"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Nastavení"</string>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="5597356221942118048">
      <item quantity="few">Zobrazit %d skryté položky</item>
      <item quantity="many">Zobrazit %d skryté položky</item>
      <item quantity="other">Zobrazit %d skrytých položek</item>
      <item quantity="one">Zobrazit %d skrytou položku</item>
    </plurals>
    <string name="network_dashboard_title" msgid="3135144174846753758">"Síť a internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="3851083934739500429">"mobilní síť"</string>
    <string name="network_dashboard_summary_data_usage" msgid="3843261364705042212">"využití dat"</string>
    <string name="network_dashboard_summary_hotspot" msgid="8494210248613254574">"hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="2355264951438890709">"Připojená zařízení"</string>
    <string name="connected_devices_dashboard_summary" msgid="2665221896894251402">"Bluetooth, režim jízdy autem, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="3840842725283655533">"Bluetooth, režim jízdy autem"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="5018708106066758867">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="5250078362483148199">"Bluetooth"</string>
    <string name="app_and_notification_dashboard_title" msgid="7838365599185397539">"Aplikace a oznámení"</string>
    <string name="app_and_notification_dashboard_summary" msgid="6513508041918469381">"Asistent, nedávné aplikace, výchozí aplikace"</string>
    <string name="notification_settings_work_profile" msgid="3186757479243373003">"Aplikace v pracovním profilu nemají přístup k oznámením."</string>
    <string name="account_dashboard_title" msgid="5895948991491438911">"Účty"</string>
    <string name="account_dashboard_default_summary" msgid="3998347400161811075">"Nebyly přidány žádné účty"</string>
    <string name="app_default_dashboard_title" msgid="7342549305933047317">"Výchozí aplikace"</string>
    <string name="system_dashboard_summary" msgid="6839969589170062254">"Jazyky, gesta, čas, záloha"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Nastavení"</string>
    <string name="keywords_wifi" msgid="3646884600964177062">"wifi, wi-fi, síť, připojení, internet, bezdrátové, data"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="8745178424405564885">"Oznámení Wi‑Fi, oznámení wifi"</string>
    <string name="keywords_auto_brightness" msgid="2109098908025156362">"Automatický jas"</string>
    <string name="keywords_vibrate_on_touch" msgid="1494239633254176598">"Zastavení vibrací, klepnutí, klávesnice"</string>
    <string name="keywords_time_format" msgid="5581515674151927461">"Používat 24hodinový formát"</string>
    <string name="keywords_storage_files" msgid="7075933058850826819">"Stažení"</string>
    <string name="keywords_app_default" msgid="5822717006354487071">"Otevřít pomocí aplikace"</string>
    <string name="keywords_applications_settings" msgid="1268353611121497450">"Aplikace"</string>
    <string name="keywords_time_zone" msgid="998254736898753085">"časové pásmo"</string>
    <string name="keywords_draw_overlay" msgid="4130899177619041842">"Hlava chatu"</string>
    <string name="keywords_flashlight" msgid="6161632177705233710">"Svítilna, světlo, baterka"</string>
    <string name="keywords_change_wifi_state" msgid="627068244033681010">"wifi, wi-fi, přepnout, ovládání"</string>
    <string name="keywords_more_mobile_networks" msgid="8995946622054642367">"mobilní síť, mobilní operátor, mobilní data, bezdrátové, data, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="1784064367330122679">"wifi, wi-fi, hovor, volání"</string>
    <string name="keywords_display" msgid="8910345814565493016">"displej, dotyková obrazovka"</string>
    <string name="keywords_display_brightness_level" msgid="3138350812626210404">"ztlumení obrazovky, dotyková obrazovka, baterie, jas"</string>
    <string name="keywords_display_night_display" msgid="2534032823231355074">"ztlumení obrazovky, noc, tónování, noční směna, jas, barva obrazovky, barvy"</string>
    <string name="keywords_display_wallpaper" msgid="7362076351860131776">"pozadí, personalizace, přizpůsobení displeje"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"velikost textu"</string>
    <string name="keywords_display_cast_screen" msgid="1209288893924324904">"projektor, odesílání, zrcadlení obrazovky, sdílení obrazovky, zrcadlení, sdílet obrazovku, odesílání obrazovky"</string>
    <string name="keywords_storage" msgid="3299217909546089225">"místo, disk, pevný disk, využití zařízení"</string>
    <string name="keywords_battery" msgid="1173830745699768388">"využití energie, nabití"</string>
    <string name="keywords_spell_checker" msgid="1399641226370605729">"pravopis, slovník, kontrola pravopisu, automatické opravy"</string>
    <string name="keywords_voice_input" msgid="769778245192531102">"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="5150660047085754699">"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="758325881602648204">"hodiny, čas"</string>
    <string name="keywords_network_reset" msgid="6024276007080940820">"resetování, obnovení, tovární nastavení"</string>
    <string name="keywords_factory_data_reset" msgid="2261491208836438871">"vymazání, smazání, obnovení, odstranění, resetování do továrního nastavení"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"tiskárna"</string>
    <string name="keywords_sounds" msgid="5633386070971736608">"pípání reproduktoru, reproduktor, hlasitost, ztlumení, ticho, zvuk, hudba"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="5426093074031208917">"nerušit, vyrušit, vyrušení, pauza"</string>
    <string name="keywords_app" msgid="6334757056536837791">"RAM"</string>
    <string name="keywords_location" msgid="4132655528196729043">"okolí, poloha, historie, hlášení, GPS"</string>
    <string name="keywords_accounts" msgid="1957925565953357627">"účet"</string>
    <string name="keywords_users" msgid="3434190133131387942">"omezení, omezit, omezeno"</string>
    <string name="keywords_keyboard_and_ime" msgid="9143339015329957107">"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="5293291209613191845">"resetování, předvolby, výchozí"</string>
    <string name="keywords_all_apps" msgid="7814015440655563156">"aplikace, stahování, systém"</string>
    <string name="keywords_app_permissions" msgid="4229936435938011023">"aplikace, oprávnění, zabezpečení"</string>
    <string name="keywords_default_apps" msgid="223872637509160136">"aplikace, výchozí"</string>
    <string name="keywords_ignore_optimizations" msgid="6102579291119055029">"ignorování optimalizací, zdřímnutí, pohotovostní režim aplikací"</string>
    <string name="keywords_color_mode" msgid="6362744316886077510">"jasné, RGB, sRGB, barva, přirozené, standardní"</string>
    <string name="keywords_color_temperature" msgid="6239410718075715449">"teplota barev, D65, D73, bílá, žlutá, modrá, teplé, studené"</string>
    <string name="keywords_lockscreen" msgid="5746561909668570047">"odemknutí přejetím prstem, heslo, gesto, PIN"</string>
    <string name="keywords_profile_challenge" msgid="789611397846512845">"pracovní výzva, práce, profil"</string>
    <string name="keywords_unification" msgid="1922900767659821025">"pracovní profil, spravovaný profil, sjednotit, sjednocení, práce, profil"</string>
    <string name="keywords_gesture" msgid="3526905012224714078">"gesta"</string>
    <string name="keywords_payment_settings" msgid="5220104934130446416">"platit, klepnout, platby"</string>
    <string name="keywords_backup" msgid="470070289135403022">"záloha, zálohování"</string>
    <string name="keywords_assist_gesture_launch" msgid="813968759791342591">"gesto"</string>
    <string name="keywords_face_unlock" msgid="254144854349092754">"obličej, odemknutí, autorizace, přihlášení"</string>
    <string name="keywords_imei_info" msgid="7230982940217544527">"imei, meid, min, verze prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="1474422416860990564">"síť, stav mobilní sítě, stav služby, síla signálu, typ mobilní sítě, roaming, iccid"</string>
    <string name="keywords_model_and_hardware" msgid="1459248377212829642">"sériové číslo, verze hardwaru"</string>
    <string name="keywords_android_version" msgid="9069747153590902819">"úroveň opravy zabezpečení androidu, verze základního pásma, verze jádra"</string>
    <string name="keywords_dark_ui_mode" msgid="8999745898782012625">"motiv, světlý, tmavý, režim"</string>
    <string name="keywords_financial_apps_sms_access" msgid="391349097813320537">"finanční aplikace, sms, oprávnění"</string>
    <string name="keywords_systemui_theme" msgid="9112852512550404882">"tmavý motiv"</string>
    <string name="keywords_device_feedback" msgid="564493721125966719">"chyba"</string>
    <string name="keywords_ambient_display_screen" msgid="5874969496073249362">"Ambientní displej, displej zámku obrazovky"</string>
    <string name="keywords_lock_screen_notif" msgid="6716392855813576197">"oznámení na obrazovce uzamčení, oznámení"</string>
    <string name="keywords_face_settings" msgid="7505388678116799329">"obličej"</string>
    <string name="keywords_fingerprint_settings" msgid="4425098764810291897">"otisk prstu, přidat otisk prstu"</string>
    <string name="keywords_display_auto_brightness" msgid="4130320471533951796">"ztlumení obrazovky, dotyková obrazovka, baterie, chytrý jas, dynamický jas"</string>
    <string name="keywords_display_adaptive_sleep" msgid="6865504720946121402">"ztlumení obrazovky, spánek, baterie, časový limit, pozornost, displej, obrazovka, neaktivita"</string>
    <string name="keywords_auto_rotate" msgid="5620879898668211494">"otočení, překlopení, rotace, na výšku, na šířku, orientace, vertikální, horizontální"</string>
    <string name="keywords_system_update_settings" msgid="7752189778843741773">"upgradovat, android"</string>
    <string name="keywords_zen_mode_settings" msgid="6526742836231604995">"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="8161370660970309476">"obrazovka, čas uzamknutí, vypršení, zámek obrazovky"</string>
    <string name="keywords_storage_settings" msgid="297283751968446577">"paměť, mezipaměť, data, smazat, vymazat, uvolnit, místo"</string>
    <string name="keywords_bluetooth_settings" msgid="6804844062789439858">"připojené, zařízení, sluchátka, náhlavní souprava, reproduktor, bezdrátové, párování, hudba, média"</string>
    <string name="keywords_wallpaper" msgid="5058364390917429896">"pozadí, obrazovka, obrazovka uzamčení, motiv"</string>
    <string name="keywords_assist_input" msgid="5017533309492679287">"výchozí, asistent"</string>
    <string name="keywords_default_payment_app" msgid="3838565809518896799">"placení, výchozí"</string>
    <string name="keywords_ambient_display" msgid="3103487805748659132">"příchozí oznámení"</string>
    <string name="keywords_hotspot_tethering" msgid="1137511742967410918">"tethering přes usb, tethering přes bluetooth, hotspot wi-fi"</string>
    <string name="keywords_touch_vibration" msgid="5983211715076385822">"hmatová odezva, vibrace, obrazovka, citlivost"</string>
    <string name="keywords_ring_vibration" msgid="4652101158979064884">"hmatová odezva, vibrace, telefon, hovor, citlivost, vyzvánění"</string>
    <string name="keywords_notification_vibration" msgid="31924624421190547">"hmatová odezva, vibrace, citlivost"</string>
    <string name="keywords_battery_saver_sticky" msgid="5586215686021650278">"spořič baterie, pevné, trvalé, úspora energie, baterie"</string>
    <string name="default_sound" msgid="8821684447333687810">"Výchozí zvuk"</string>
    <string name="sound_settings_summary" msgid="4100853606668287965">"Hlasitost vyzvánění: <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="3402435125958012986">"Hlasitost, vibrace, režim Nerušit"</string>
    <string name="sound_settings_summary_vibrate" msgid="1869282574422220096">"Vyzvánění bylo nastaveno na vibrace"</string>
    <string name="sound_settings_summary_silent" msgid="5074529767435584948">"Vyzvánění bylo ztlumeno"</string>
    <string name="sound_settings_example_summary" msgid="2404914514266523165">"Hlasitost vyzvánění: 80 %"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Hlasitost médií"</string>
    <string name="remote_media_volume_option_title" msgid="7602586327091007461">"Hlasitost odesílání"</string>
    <string name="call_volume_option_title" msgid="1265865226974255384">"Hlasitost hovoru"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Hlasitost budíku"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Hlasitost vyzvánění"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Hlasitost oznámení"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Vyzváněcí tón telefonu"</string>
    <string name="notification_ringtone_title" msgid="4468722874617061231">"Výchozí zvuk oznámení"</string>
    <string name="notification_unknown_sound_title" msgid="2535027767851838335">"Zvuk z aplikace"</string>
    <string name="notification_sound_default" msgid="565135733949733766">"Výchozí zvuk oznámení"</string>
    <string name="alarm_ringtone_title" msgid="6344025478514311386">"Výchozí zvuk budíku"</string>
    <string name="vibrate_when_ringing_title" msgid="8658910997501323472">"Vibrace u volání"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Ostatní zvuky"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Tóny číselníku"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Zvuky zámku obrazovky"</string>
    <string name="charging_sounds_title" msgid="3379885700913955599">"Zvuky a vibrace při nabíjení"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Zvuky při vložení do doku"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Zvuky při dotyku"</string>
    <string name="vibrate_on_touch_title" msgid="1510405818894719079">"Vibrace dotykové obrazovky"</string>
    <string name="vibrate_on_touch_summary" msgid="8015901758501868229">"Hmatová odezva pro klepnutí, klávesnici a další"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Zvuk reproduktoru doku"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Veškerý zvuk"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Pouze mediální soubory"</string>
    <string name="emergency_tone_silent" msgid="3750231842974733677">"Ticho"</string>
    <string name="emergency_tone_alert" msgid="8523447641290736852">"Zvuk"</string>
    <string name="emergency_tone_vibrate" msgid="2278872257053690683">"Vibrace"</string>
    <string name="boot_sounds_title" msgid="567029107382343709">"Zvuky při spouštění"</string>
    <string name="live_caption_title" msgid="2241633148129286971">"Okamžitý přepis"</string>
    <string name="live_caption_summary" msgid="3365960379606535783">"Automatické titulky k médiím"</string>
    <string name="zen_mode_settings_summary_off" msgid="6119891445378113334">"Nikdy"</string>
    <plurals name="zen_mode_settings_summary_on" formatted="false" msgid="2249085722517252521">
      <item quantity="few"><xliff:g id="ON_COUNT">%d</xliff:g> aktivována</item>
      <item quantity="many"><xliff:g id="ON_COUNT">%d</xliff:g> aktivováno</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> aktivováno</item>
      <item quantity="one">1 aktivováno</item>
    </plurals>
    <string name="zen_mode_settings_title" msgid="1066226840983908121">"Nerušit"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="2297134204747331078">"Zapněte funkci Nerušit"</string>
    <string name="zen_mode_behavior_settings_title" msgid="5453115212674008032">"Výjimky"</string>
    <string name="zen_mode_duration_settings_title" msgid="8471983919324532829">"Výchozí doba trvání"</string>
    <string name="zen_mode_behavior_allow_title" msgid="3845615648136218141">"Povolit zvuky a vibrace pro"</string>
    <string name="zen_mode_behavior_no_sound" msgid="1219626004723208056">"Žádné zvuky"</string>
    <string name="zen_mode_behavior_total_silence" msgid="2229976744274214528">"Úplné ticho"</string>
    <string name="zen_mode_behavior_no_sound_except" msgid="4968477585788243114">"Žádné zvuky. Výjimka: <xliff:g id="CATEGORIES">%1$s</xliff:g>"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="6455884547877702466">"Žádné zvuky kromě budíků a médií"</string>
    <string name="zen_mode_automation_settings_title" msgid="6155298704165984370">"Plány"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5975522152123354381">"Smazání plánů"</string>
    <string name="zen_mode_schedule_delete" msgid="5717258786128155695">"Smazat"</string>
    <string name="zen_mode_rule_name_edit" msgid="812185626159430507">"Upravit"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="8995524726286378583">"Plány"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="4773111805919088437">"Plán"</string>
    <string name="zen_mode_schedule_category_title" msgid="5482757877262584975">"Plán"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="4321254843908888574">"Ztlumit telefon v určitou dobu"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="6223252025075862701">"Nastavit pravidla režimu Nerušit"</string>
    <string name="zen_mode_schedule_title" msgid="8616187805239590649">"Plán"</string>
    <string name="zen_mode_use_automatic_rule" msgid="489102635414919052">"Použít plán"</string>
    <string name="zen_mode_option_important_interruptions" msgid="3903928008177972500">"Pouze prioritní"</string>
    <string name="zen_mode_option_alarms" msgid="5785372117288803600">"Pouze budíky"</string>
    <string name="zen_mode_option_no_interruptions" msgid="8107126344850276878">"Úplné ticho"</string>
    <string name="zen_mode_summary_combination" msgid="8715563402849273459">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="6751708745442997940">"Blokovat vizuální vyrušení"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="6308824824208120508">"Povolit vizuální signály"</string>
    <string name="zen_mode_settings_category" msgid="8404473163624911791">"Když je zapnut režim Nerušit"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="8138441771855063771">"Omezit oznámení"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="3690261619682396872">"Oznámení bez zvukového upozornění"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="5810076116489877312">"Oznámení se zobrazí na obrazovce"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="3465600930732602159">"Nová oznámení nebudou vydávat zvuk ani vibrovat"</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5305121630186687339">"Oznámení bez vizuálního a zvukového upozornění"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="7555448406901864904">"Oznámení nebudou vidět ani slyšet"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="1069960859746788356">"Telefon nebude zobrazovat nová ani stávající oznámení a nebude při nich ani vibrovat či vyzvánět. Kritická oznámení související s aktivitou a stavem telefonu se však nadále zobrazovat budou.\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="7498689167767941034">"Vlastní"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4250962169561739747">"Aktivovat vlastní nastavení"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="6676997522330453597">"Odstranit vlastní nastavení"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="5450158135853888485">"Oznámení bez zvukového upozornění"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="7416121534987213074">"Částečně skryté"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="3618285192806732504">"Oznámení bez vizuálního a zvukového upozornění"</string>
    <string name="zen_mode_what_to_block_title" msgid="5480903548365697159">"Vlastní omezení"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="4659484530849212827">"Když je obrazovka zapnutá"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="4276414460889400625">"Když je obrazovka vypnutá"</string>
    <string name="zen_mode_block_effect_sound" msgid="7383953383758025895">"Ztlumit zvuk a vibrace"</string>
    <string name="zen_mode_block_effect_intent" msgid="350764335391428447">"Nezapínat obrazovku"</string>
    <string name="zen_mode_block_effect_light" msgid="8106976110224107316">"Neblikat"</string>
    <string name="zen_mode_block_effect_peek" msgid="6836997464098657115">"Nezobrazovat oznámení na obrazovce"</string>
    <string name="zen_mode_block_effect_status" msgid="1651527249762752921">"Skrýt ikony stavového řádku v horní části obrazovky"</string>
    <string name="zen_mode_block_effect_badge" msgid="214553506070597320">"Skrýt puntíky s oznámením na ikonách aplikací"</string>
    <string name="zen_mode_block_effect_ambient" msgid="4704755879961212658">"Nebudit kvůli oznámením"</string>
    <string name="zen_mode_block_effect_list" msgid="3882541635576592530">"Skrýt ze seznamu oznámení"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="2617875282623486256">"Nikdy"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="1230265589026355094">"Při vypnuté obrazovce"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="6017536991063513394">"Při zapnuté obrazovce"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1065107568053759972">"Zvuk a vibrace"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="3635646031575107456">"Zvuk, vibrace a některá vizuální upozornění na oznámení"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="1213328945418248026">"Zvuk, vibrace a vizuální upozornění na oznámení"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="5710896246703497760">"Oznámení potřebná pro základní činnost a stav telefonu nebudou skryta nikdy"</string>
    <string name="zen_mode_no_exceptions" msgid="7653433997399582247">"Žádné"</string>
    <string name="zen_mode_other_options" msgid="520015080445012355">"další možnosti"</string>
    <string name="zen_mode_add" msgid="90014394953272517">"Přidat"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="8287824809739581837">"Zapnout"</string>
    <string name="zen_mode_button_turn_on" msgid="2824380626482175552">"Zapnout"</string>
    <string name="zen_mode_button_turn_off" msgid="6181953727880503094">"Vypnout"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8860646554263965569">"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="7186615007561990908">"Režim Nerušit zůstane zapnut, dokud ho nevypnete"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="6195725842906270996">"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="1721179577382915270">"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="1965922539531521052">"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="7555742240858292255"><annotation id="link">" Zobrazit vlastní nastavení"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="2078370238113347720">"Pouze prioritní"</string>
    <string name="zen_mode_and_condition" msgid="4927230238450354412">"<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="1202632669798211342">"Zapnuto / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off_with_info" msgid="2348629457144123849">"Vypnuto / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off" msgid="4375814717589425561">"Vypnuto"</string>
    <string name="zen_mode_sound_summary_on" msgid="7718273231309882914">"Zapnuto"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="5976427426278136178">"Pokaždé se zeptat (pokud se nezapne automaticky)"</string>
    <string name="zen_mode_duration_summary_forever" msgid="3144786357459137066">"Dokud ho nevypnete (pokud se nezapne automaticky)"</string>
    <plurals name="zen_mode_duration_summary_time_hours" formatted="false" msgid="1060823390336822337">
      <item quantity="few"><xliff:g id="NUM_HOURS">%d</xliff:g> hodiny (pokud se nezapne automaticky)</item>
      <item quantity="many"><xliff:g id="NUM_HOURS">%d</xliff:g> hodiny (pokud se nezapne automaticky)</item>
      <item quantity="other"><xliff:g id="NUM_HOURS">%d</xliff:g> hodin (pokud se nezapne automaticky)</item>
      <item quantity="one">1 hodina (pokud se nezapne automaticky)</item>
    </plurals>
    <string name="zen_mode_duration_summary_time_minutes" msgid="3959860288930526323">"<xliff:g id="NUM_MINUTES">%d</xliff:g> min (pokud se nezapne automaticky)"</string>
    <plurals name="zen_mode_sound_summary_summary_off_info" formatted="false" msgid="6751226506661227581">
      <item quantity="few"><xliff:g id="ON_COUNT">%d</xliff:g> plány se mohou zapnout automaticky</item>
      <item quantity="many"><xliff:g id="ON_COUNT">%d</xliff:g> plánu se může zapnout automaticky</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> plánů se může zapnout automaticky</item>
      <item quantity="one">1 plán se může zapnout automaticky</item>
    </plurals>
    <string name="zen_category_behavior" msgid="554277240833452070">"Vypnout zvuk zařízení, ale povolit výjimky"</string>
    <string name="zen_category_exceptions" msgid="7601136604273265629">"Výjimky"</string>
    <string name="zen_category_schedule" msgid="9000447592251450453">"Plán"</string>
    <string name="zen_sound_title" msgid="4461494611692749446">"Zobrazit všechny výjimky"</string>
    <string name="zen_sound_footer" msgid="7621745273287208979">"Když je zapnut režim Nerušit, zvuky a vibrace budou ztlumeny (kromě položek, které povolíte výše)."</string>
    <string name="zen_sound_category_title" msgid="4336596939661729188">"Ztlumeno vše kromě"</string>
    <string name="zen_sound_all_muted" msgid="4850363350480968114">"Ztlumeno"</string>
    <string name="zen_sound_none_muted" msgid="3938508512103612527">"Neztlumeno"</string>
    <string name="zen_sound_one_allowed" msgid="8447313454438932276">"Ztlumeno, ale povolit <xliff:g id="SOUND_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_sound_two_allowed" msgid="980491120444358550">"Ztlumeno, ale povolit <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g> a <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_sound_three_allowed" msgid="3455767205934547985">"Ztlumeno, ale povolit <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g>, <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g> a <xliff:g id="SOUND_TYPE_2">%3$s</xliff:g>"</string>
    <string name="zen_custom_settings_dialog_title" msgid="3999383687283620283">"Vlastní nastavení"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="7056997717364939238">"Zkontrolovat plán"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="5302885851078421866">"Rozumím"</string>
    <string name="zen_custom_settings_notifications_header" msgid="6931035609369698584">"Oznámení"</string>
    <string name="zen_custom_settings_duration_header" msgid="1190989278065507035">"Trvání"</string>
    <string name="zen_msg_event_reminder_title" msgid="5137894077488924820">"Zprávy, události a připomenutí"</string>
    <string name="zen_msg_event_reminder_footer" msgid="4376930591019535192">"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="6131211000824433013">"Hotovo"</string>
    <string name="zen_onboarding_settings" msgid="9046451821239946868">"Nastavení"</string>
    <string name="zen_onboarding_new_setting_title" msgid="1893095176110470711">"Oznámení bez vizuálního a zvukového upozornění"</string>
    <string name="zen_onboarding_current_setting_title" msgid="776426065129609376">"Oznámení bez zvukového upozornění"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="6293026064871880706">"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="1280614488924843713">"(Aktuální nastavení)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="1352808651270918932">"Chcete změnit nastavení oznámeni režimu Nerušit?"</string>
    <string name="sound_work_settings" msgid="6774324553228566442">"Zvuky pracovního profilu"</string>
    <string name="work_use_personal_sounds_title" msgid="1148331221338458874">"Použít zvuky osobního profilu"</string>
    <string name="work_use_personal_sounds_summary" msgid="6207040454949823153">"Zvuky pracovního a osobního profilu jsou stejné"</string>
    <string name="work_ringtone_title" msgid="5806657896300235315">"Vyzváněcí tón prac. telefonu"</string>
    <string name="work_notification_ringtone_title" msgid="6081247402404510004">"Výchozí zvuk pracovního oznámení"</string>
    <string name="work_alarm_ringtone_title" msgid="1441926676833738891">"Výchozí zvuk pracovního budíku"</string>
    <string name="work_sound_same_as_personal" msgid="3123383644475266478">"Stejné jako v osobním profilu"</string>
    <string name="work_sync_dialog_title" msgid="7123973297187354813">"Nahradit zvuky?"</string>
    <string name="work_sync_dialog_yes" msgid="7243884940551635717">"Nahradit"</string>
    <string name="work_sync_dialog_message" msgid="7841728953710863208">"Pro pracovní profil budou použity zvuky z osobního profilu"</string>
    <string name="ringtones_install_custom_sound_title" msgid="5948792721161302255">"Přidat vlastní zvuk?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="2195581481608512786">"Soubor bude zkopírován do složky <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="5675912303120102366">"Vyzváněcí tóny"</string>
    <string name="other_sound_category_preference_title" msgid="2521096636124314015">"Další zvuky a vibrace"</string>
    <string name="configure_notification_settings" msgid="7616737397127242615">"Oznámení"</string>
    <string name="recent_notifications" msgid="5660639387705060156">"Nedávno odeslané"</string>
    <string name="recent_notifications_see_all_title" msgid="8572160812124540326">"Zobrazit vše za posledních 7 dní"</string>
    <string name="advanced_section_header" msgid="8833934850242546903">"Rozšířená nastavení"</string>
    <string name="profile_section_header" msgid="2320848161066912001">"Pracovní oznámení"</string>
    <string name="asst_capability_prioritizer_title" msgid="1008391045235540115">"Automatické priority oznámení"</string>
    <string name="asst_capability_prioritizer_summary" msgid="7174545871607005997">"Automaticky ztlumit a posunout dolů méně důležitá oznámení"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="2482989905050401969">"Chytré akce a odpovědi"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="2200584362919192199">"Automaticky přidat kontextové akce a rychlé odpovědi na oznámení"</string>
    <string name="hide_silent_icons_title" msgid="2378514357635207742">"Skrýt stavové ikony tichých oznámení"</string>
    <string name="hide_silent_icons_summary" msgid="7479863645940885952">"Skrýt ikony tichých oznámení na stavovém řádku"</string>
    <string name="notification_badging_title" msgid="5938709971403474078">"Povolit puntíky s oznámením"</string>
    <string name="notification_bubbles_title" msgid="526545466417027926">"Bubliny"</string>
    <string name="notification_bubbles_summary" msgid="5269674863510678257">"Rychlý přístup k obsahu aplikací odkudkoli pomocí plovoucích zkratek"</string>
    <string name="bubbles_feature_education" msgid="69923617148394578">"Některá oznámení a další obsah se mohou zobrazovat jako bubliny na obrazovce. Bublinu otevřete klepnutím. Zavřete ji přetažením dolů."</string>
    <string name="bubbles_app_toggle_title" msgid="9143702245165359360">"Bubliny"</string>
    <string name="bubbles_app_toggle_summary" msgid="7714358008428342285">"Povolit aplikaci <xliff:g id="APP_NAME">%1$s</xliff:g> zobrazovat některá oznámení jako bubliny"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="8013961655723563787">"Zapnutí bublin"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="3616822820657195387">"Chcete-li u této aplikace zapnout bubliny, musíte je nejdřív zapnout v zařízení. Toto nastavení má vliv na ostatní aplikace, u kterých jste bubliny již dříve zapnuli."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="5317196831268846883">"Zapnout v zařízení"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8176870537170586852">"Zrušit"</string>
    <string name="swipe_direction_title" msgid="6877543492435053137">"Akce po přejetí prstem"</string>
    <string name="swipe_direction_ltr" msgid="3623394320915041215">"Přejetím vpravo zavřete, přejetím vlevo zobrazíte nabídku"</string>
    <string name="swipe_direction_rtl" msgid="4972099509548044938">"Přejetím vlevo zavřete, přejetím vpravo zobrazíte nabídku"</string>
    <string name="notification_pulse_title" msgid="1905382958860387030">"Blikání kontrolky"</string>
    <string name="lock_screen_notifications_title" msgid="2583595963286467672">"Na obrazovce uzamčení"</string>
    <string name="locked_work_profile_notification_title" msgid="8327882003361551992">"Když je profil uzamčen"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Zobrazit veškerý obsah oznámení"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="8301305044690264958">"Skrýt citlivý obsah"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="859628910427886715">"Oznámení vůbec nezobrazovat"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6164532459432182244">"Jak chcete zobrazovat oznámení, když bude zařízení uzamčeno?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1416589393106326972">"Oznámení"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="835870815661120772">"Zobrazit veškerý obsah pracovních oznámení"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2005907007779384635">"Skrýt citlivý pracovní obsah"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="8307705621027472346">"Jak chcete zobrazovat profilová oznámení, když bude zařízení uzamčeno?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="3169806586032521333">"Profilová oznámení"</string>
    <string name="notifications_title" msgid="8086372779371204971">"Oznámení"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Oznámení"</string>
    <string name="notification_channel_title" msgid="2260666541030178452">"Kategorie oznámení"</string>
    <string name="notification_group_title" msgid="7180506440133859601">"Skupina kategorií oznámení"</string>
    <string name="notification_importance_title" msgid="4368578960344731828">"Chování"</string>
    <string name="notification_importance_unspecified" msgid="6622173510486113958">"Povolit zvuk"</string>
    <string name="notification_importance_blocked" msgid="7938180808339386300">"Oznámení nikdy nezobrazovat"</string>
    <string name="notification_importance_min" msgid="9054819132085066824">"Zobrazit tiše a minimalizovat"</string>
    <string name="notification_importance_low" msgid="2445139943005315690">"Zobrazovat tiše"</string>
    <string name="notification_importance_default" msgid="5958338024601957516">"Vydat zvukový signál"</string>
    <string name="notification_importance_high" msgid="2082429479238228527">"Vydat zvukový signál a vyskočit na obrazovku"</string>
    <string name="notification_importance_high_silent" msgid="2667033773703765252">"Vyskočit na obrazovce"</string>
    <string name="notification_importance_min_title" msgid="5024538864029341539">"Minimalizovat"</string>
    <string name="notification_importance_low_title" msgid="8131254047772814309">"Střední"</string>
    <string name="notification_importance_default_title" msgid="9120383978536089489">"Vysoká"</string>
    <string name="notification_importance_high_title" msgid="8792310396497954857">"Vyskočit na obrazovce"</string>
    <string name="notification_block_title" msgid="1366361048463539674">"Blok"</string>
    <string name="notification_silence_title" msgid="6082383633107433802">"Zobrazovat tiše"</string>
    <string name="notification_alert_title" msgid="7755552340126176938">"Upozornění"</string>
    <string name="allow_interruption" msgid="7136150018111848721">"Povolit vyrušení"</string>
    <string name="allow_interruption_summary" msgid="7870159391333957050">"Umožněte aplikacím vydávat zvuky, vibrovat nebo zobrazovat oznámení na obrazovce"</string>
    <string name="notification_channel_summary_min" msgid="5401718014765921892">"Nízká důležitost"</string>
    <string name="notification_channel_summary_low" msgid="322317684244981244">"Střední důležitost"</string>
    <string name="notification_channel_summary_default" msgid="1111749130423589931">"Vysoká důležitost"</string>
    <string name="notification_channel_summary_high" msgid="2085017556511003283">"Urgentní důležitost"</string>
    <string name="notification_switch_label" msgid="6843075654538931025">"Zobrazit oznámení"</string>
    <string name="default_notification_assistant" msgid="7631945224761430146">"Asistent oznámení"</string>
    <string name="notifications_sent_daily" msgid="3584506541352710975">"zhruba <xliff:g id="NUMBER">%1$s</xliff:g> za den"</string>
    <string name="notifications_sent_weekly" msgid="1030525736746720584">"zhruba <xliff:g id="NUMBER">%1$s</xliff:g> za týden"</string>
    <string name="notifications_sent_never" msgid="1001964786456700536">"Nikdy"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Přístup k oznámením"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8748026238701253040">"Přístup k oznámením pracovního profilu je zablokován"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Aplikace nesmí číst oznámení"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="7930130030691218387">
      <item quantity="few">%d aplikace mohou číst oznámení</item>
      <item quantity="many">%d aplikace může číst oznámení</item>
      <item quantity="other">%d aplikací může číst oznámení</item>
      <item quantity="one">%d aplikace může číst oznámení</item>
    </plurals>
    <string name="notification_assistant_title" msgid="4788805096903794353">"Asistent oznámení"</string>
    <string name="no_notification_assistant" msgid="3230229194702623108">"Žádný asistent"</string>
    <string name="no_notification_listeners" msgid="3487091564454192821">"Žádné nainstalované aplikace o přístup k oznámením nepožádaly."</string>
    <string name="notification_assistant_security_warning_title" msgid="300600401595343861">"Povolit službě <xliff:g id="SERVICE">%1$s</xliff:g> přístup k oznámením?"</string>
    <string name="notification_assistant_security_warning_summary" msgid="5829972610310154776">"Aplikace <xliff:g id="NOTIFICATION_ASSISTANT_NAME">%1$s</xliff:g> bude moci číst všechna oznámení, včetně osobních údajů, jako jsou jména kontaktů a texty zpráv, které obdržíte. Bude také moci oznámení změnit, zavřít nebo aktivovat tlačítka akcí, která obsahují. \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="notification_listener_security_warning_title" msgid="5522924135145843279">"Povolit službě <xliff:g id="SERVICE">%1$s</xliff:g> přístup k oznámením?"</string>
    <string name="notification_listener_security_warning_summary" msgid="119203147791040151">"Aplikace <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> bude moci číst všechna oznámení, včetně osobních údajů, jako jsou jména kontaktů a texty zpráv, které obdržíte. Bude také moci oznámení zavřít nebo aktivovat tlačítka akcí, která obsahují. \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="notification_listener_disable_warning_summary" msgid="6738915379642948000">"Pokud aplikaci <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> vypnete přístup k oznámení, může dojít i k vypnutí přístupu v režimu Nerušit."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="8333442186428083057">"Vypnout"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8586417377104211584">"Zrušit"</string>
    <string name="vr_listeners_title" msgid="1318901577754715777">"Pomocné služby VR"</string>
    <string name="no_vr_listeners" msgid="2689382881717507390">"Žádné nainstalované aplikace nepožádaly o spuštění jako pomocná služba VR."</string>
    <string name="vr_listener_security_warning_title" msgid="8309673749124927122">"Povolit přístup k VR službě pro <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="6931541068825094653">"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="8104485269504335481">"Když je zařízení v režimu VR"</string>
    <string name="display_vr_pref_low_persistence" msgid="5707494209944718537">"Snížit rozmazání (doporučeno)"</string>
    <string name="display_vr_pref_off" msgid="2190091757123260989">"Snížit mihotání"</string>
    <string name="picture_in_picture_title" msgid="5824849294270017113">"Obraz v obraze"</string>
    <string name="picture_in_picture_empty_text" msgid="685224245260197779">"Žádná nainstalovaná aplikace nepodporuje režim obraz v obraze"</string>
    <string name="picture_in_picture_keywords" msgid="8361318686701764690">"obraz v obraze"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4080800421316791732">"Obraz v obraze"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="1131910667023738296">"Povolit obraz v obraze"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="1264019085827708920">"Povolí této aplikaci vytvořit okno v režimu obraz v obraze, když je aplikace otevřená nebo poté, co ji opustíte (například abyste mohli pokračovat ve sledování videa). Toto okno se zobrazuje nad ostatními aplikacemi, které používáte."</string>
    <string name="manage_zen_access_title" msgid="2611116122628520522">"Přístup při nastavení Nerušit"</string>
    <string name="zen_access_detail_switch" msgid="1188754646317450926">"Povolit režim Nerušit"</string>
    <string name="zen_access_empty_text" msgid="8772967285742259540">"O přístup při nastavení Nerušit nepožádaly žádné nainstalované aplikace"</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Načítání aplikací..."</string>
    <string name="app_notifications_off_desc" msgid="8289223211387083447">"Oznámení této aplikace jsou v zařízení na vaši žádost blokována systémem Android"</string>
    <string name="channel_notifications_off_desc" msgid="9013011134681491778">"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="2315252834146837470">"Tato skupina oznámení je v zařízení na vaši žádost blokována systémem Android"</string>
    <string name="notification_channels" msgid="5346841743182627500">"Kategorie"</string>
    <string name="notification_channels_other" msgid="5645317113885788226">"Jiné"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="3420621520561455358">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategorie</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> kategorie</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategorií</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> kategorie</item>
    </plurals>
    <string name="no_channels" msgid="3077375508177744586">"Tato aplikace neodeslala žádná oznámení"</string>
    <string name="app_settings_link" msgid="8894946007543660906">"Další nastavení v aplikaci"</string>
    <string name="app_notification_listing_summary_zero" msgid="8046168435207424440">"Zapnuto pro všechny aplikace"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="6709582776823665660">
      <item quantity="few">Vypnuto pro <xliff:g id="COUNT_1">%d</xliff:g> aplikace</item>
      <item quantity="many">Vypnuto pro <xliff:g id="COUNT_1">%d</xliff:g> aplikace</item>
      <item quantity="other">Vypnuto pro <xliff:g id="COUNT_1">%d</xliff:g> aplikací</item>
      <item quantity="one">Vypnuto pro <xliff:g id="COUNT_0">%d</xliff:g> aplikaci</item>
    </plurals>
    <plurals name="deleted_channels" formatted="false" msgid="8028574302599397935">
      <item quantity="few">Byly smazány <xliff:g id="COUNT_1">%d</xliff:g> kategorie</item>
      <item quantity="many">Bylo smazáno <xliff:g id="COUNT_1">%d</xliff:g> kategorie</item>
      <item quantity="other">Bylo smazáno <xliff:g id="COUNT_1">%d</xliff:g> kategorií</item>
      <item quantity="one">Byla smazána <xliff:g id="COUNT_0">%d</xliff:g> kategorie</item>
    </plurals>
    <string name="notification_toggle_on" msgid="650145396718191048">"Zapnuto"</string>
    <string name="notification_toggle_off" msgid="2142010737190671762">"Vypnuto"</string>
    <string name="app_notification_block_title" msgid="4069351066849087649">"Blokovat vše"</string>
    <string name="app_notification_block_summary" msgid="4744020456943215352">"Tato oznámení nikdy nezobrazovat"</string>
    <string name="notification_content_block_title" msgid="5854232570963006360">"Zobrazovat oznámení"</string>
    <string name="notification_content_block_summary" msgid="7746185794438882389">"Nezobrazovat oznámení na panelu ani v periferních zařízeních"</string>
    <string name="notification_badge_title" msgid="6370122441168519809">"Povolit puntík s oznámením"</string>
    <string name="notification_channel_badge_title" msgid="2240827899882847087">"Zobrazit puntík s oznámením"</string>
    <string name="app_notification_override_dnd_title" msgid="7867458246395884830">"Přepsat nastavení Nerušit"</string>
    <string name="app_notification_override_dnd_summary" msgid="2612502099373472686">"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="7821124557634786985">"Na obrazovce uzamčení"</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"Blokované"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Prioritní"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Důvěrné"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"Hotovo"</string>
    <string name="app_notification_importance_title" msgid="8002263131149345584">"Důležitost"</string>
    <string name="notification_show_lights_title" msgid="7671781299688190532">"Blikání kontrolky"</string>
    <string name="notification_vibrate_title" msgid="1646667807969755957">"Vibrace"</string>
    <string name="notification_channel_sound_title" msgid="3899212238513507941">"Zvuk"</string>
    <string name="zen_mode_rule_delete_button" msgid="903658142711011617">"Smazat"</string>
    <string name="zen_mode_rule_rename_button" msgid="4642843370946599164">"Přejmenovat"</string>
    <string name="zen_mode_rule_name" msgid="5607736317244760638">"Název plánu"</string>
    <string name="zen_mode_rule_name_hint" msgid="278109122579468433">"Zadejte název plánu"</string>
    <string name="zen_mode_rule_name_warning" msgid="3856485373110366912">"Název plánu se už používá"</string>
    <string name="zen_mode_add_rule" msgid="7459154136384467057">"Přidat další"</string>
    <string name="zen_mode_add_event_rule" msgid="4454759739839069898">"Přidat plán události"</string>
    <string name="zen_mode_add_time_rule" msgid="7890557350868257760">"Přidat časový plán"</string>
    <string name="zen_mode_delete_rule" msgid="8055032645990309096">"Smazat plán"</string>
    <string name="zen_mode_choose_rule_type" msgid="40993242338494595">"Vyberte typ plánu"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6237882294348570283">"Smazat pravidlo <xliff:g id="RULE">%1$s</xliff:g>?"</string>
    <string name="zen_mode_delete_rule_button" msgid="4248741120307752294">"Smazat"</string>
    <string name="zen_mode_rule_type_unknown" msgid="3049377282766700600">"Neznámé"</string>
    <string name="zen_mode_app_set_behavior" msgid="1534429320064381355">"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="2558968232814237874">"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="6200424436456086312">"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="6163149826036287324">"Čas"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="3379499360390382259">"Automatické pravidlo bylo nastaveno na Nerušit v určitých časech"</string>
    <string name="zen_event_rule_type_name" msgid="6503468472212606158">"Událost"</string>
    <string name="zen_event_rule_enabled_toast" msgid="6910577623330811480">"Automatické pravidlo bylo nastaveno na Nerušit během určitých událostí"</string>
    <string name="zen_mode_event_rule_calendar" msgid="8787906563769067418">"Během událostí"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="5135844750232403975">"Během událostí <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="4936646399126636358">"v libovolném kalendáři"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="6590671260829837157">"V případě odpovědi <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="6485568415998569885">"V libovolném kalendáři"</string>
    <string name="zen_mode_event_rule_reply" msgid="5166322024212403739">"V případě odpovědi"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="8868873496008825961">"Ano, možná nebo žádná odpověď"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="2769656565454495824">"Ano nebo možná"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="1003598835878784659">"Ano"</string>
    <string name="zen_mode_rule_not_found_text" msgid="8963662446092059836">"Pravidlo nebylo nalezeno."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="976098744828219297">"Zapnuto / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="2101201392041867409">"<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="3195058680641389948">"Dny"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="4954143628634166317">"Žádná"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="146511166522076034">"Každý den"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="767054141267122030">"Budík může přepsat čas ukončení"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="1673667979187593693">"Naplánovat vypnutí po zazvonění budíku"</string>
    <string name="zen_mode_custom_behavior_title" msgid="1148856394866360783">"Chování režimu Nerušit"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="7750128187766412708">"Použít výchozí nastavení"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="7458258833216726120">"Vytvořit vlastní nastavení pro tento plán"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="4070854282812755247">"Pro: <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>"</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="summary_range_symbol_combination" msgid="5695218513421897027">"<xliff:g id="START">%1$s</xliff:g> – <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="8467306662961568656">"<xliff:g id="START">%1$s</xliff:g> až <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_calls" msgid="4769117032399813012">"Povolit hovory"</string>
    <string name="zen_mode_calls_title" msgid="2905770092665685857">"Volání"</string>
    <string name="zen_mode_calls_footer" msgid="2002070641802102110">"Chcete-li zajistit, aby povolená volání vydávala zvuk, zkontrolujte, zda je zařízení nastavené na vyzvánění, vibraci či tichý režim."</string>
    <string name="zen_mode_custom_calls_footer" msgid="4764756801941329281">"V plánu <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> jsou blokovány příchozí hovory. Nastavení můžete upravit, aby se s vámi mohli spojit kamarádi, členové rodiny nebo jiné vybrané kontakty."</string>
    <string name="zen_mode_starred_contacts_title" msgid="1848464279786960190">"Kontakty označené hvězdičkou"</string>
    <plurals name="zen_mode_starred_contacts_summary_additional_contacts" formatted="false" msgid="500105380255018671">
      <item quantity="few"><xliff:g id="NUM_PEOPLE">%d</xliff:g> další</item>
      <item quantity="many"><xliff:g id="NUM_PEOPLE">%d</xliff:g> dalšího</item>
      <item quantity="other"><xliff:g id="NUM_PEOPLE">%d</xliff:g> dalších</item>
      <item quantity="one">1 další</item>
    </plurals>
    <string name="zen_mode_messages" msgid="3463040297974005265">"Povolit textové zprávy"</string>
    <string name="zen_mode_messages_footer" msgid="2616568463646674149">"Chcete-li zajistit, aby povolené zprávy vydávaly zvuk, zkontrolujte, zda je zařízení nastavené na vyzvánění, vibraci či tichý režim."</string>
    <string name="zen_mode_custom_messages_footer" msgid="356699532253965350">"V plánu <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> jsou blokovány příchozí textové 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_messages_title" msgid="7325983674655986445">"SMS, MMS a aplikace k psaní zpráv"</string>
    <string name="zen_mode_from_anyone" msgid="2638322015361252161">"Od kohokoli"</string>
    <string name="zen_mode_from_contacts" msgid="2232335406106711637">"Pouze od kontaktů"</string>
    <string name="zen_mode_from_starred" msgid="2678345811950997027">"Pouze od oblíbených kontaktů"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="4046151920710059778">"Od kontaktů s hvězdičkou a lidí, co volají opakovaně"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="1528716671301999084">"Od kontaktů a lidí, co volají opakovaně"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7105261473107715445">"Pouze od lidí, co volají opakovaně"</string>
    <string name="zen_mode_from_none" msgid="8219706639954614136">"Žádné"</string>
    <string name="zen_mode_from_none_calls" msgid="7705112158761351044">"Nepovolit žádné hovory"</string>
    <string name="zen_mode_from_none_messages" msgid="3300937656725582608">"Nepovolit žádné zprávy"</string>
    <string name="zen_mode_alarms" msgid="6510378757005935647">"Povolit budíky"</string>
    <string name="zen_mode_alarms_list" msgid="1090332840207025714">"budíky"</string>
    <string name="zen_mode_media" msgid="4529187475698084320">"Přehrávat zvuky médií"</string>
    <string name="zen_mode_media_list" msgid="5483540766397328038">"média"</string>
    <string name="zen_mode_system" msgid="236278770843463810">"Povolit zvuky při dotyku"</string>
    <string name="zen_mode_system_list" msgid="6996104733185177115">"zvuky při dotyku"</string>
    <string name="zen_mode_reminders" msgid="5445657061499098675">"Povolit připomenutí"</string>
    <string name="zen_mode_reminders_list" msgid="2853975802240340190">"připomenutí"</string>
    <string name="zen_mode_events" msgid="6154853744271591007">"Povolit události"</string>
    <string name="zen_mode_bypassing_apps" msgid="5493729796981237881">"Povolit přepisování aplikací"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="2072590348079644482">"Výjimky aplikací"</string>
    <plurals name="zen_mode_bypassing_apps_subtext" formatted="false" msgid="3726913165356014788">
      <item quantity="few">Oznámení z <xliff:g id="NUMBER">%1$d</xliff:g> aplikací mohou režim Nerušit obejít</item>
      <item quantity="many">Oznámení z <xliff:g id="NUMBER">%1$d</xliff:g> aplikace mohou režim Nerušit obejít</item>
      <item quantity="other">Oznámení z <xliff:g id="NUMBER">%1$d</xliff:g> aplikací mohou režim Nerušit obejít</item>
      <item quantity="one">Oznámení z 1 aplikace mohou režim Nerušit obejít</item>
    </plurals>
    <string name="zen_mode_events_list" msgid="5571368229052715098">"události"</string>
    <string name="zen_mode_all_callers" msgid="2378065871253871057">"kdokoli"</string>
    <string name="zen_mode_contacts_callers" msgid="5569804103920394175">"kontakty"</string>
    <string name="zen_mode_starred_callers" msgid="1023167821338514140">"kontakty s hvězdičkou"</string>
    <string name="zen_mode_repeat_callers" msgid="5019521886428322131">"Volající, kteří volají opakovaně"</string>
    <string name="zen_mode_repeat_callers_list" msgid="2529895519653237330">"opakovaná volání"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8553876328249671783">"Povolit opakovaná volání"</string>
    <string name="zen_mode_calls_summary_one" msgid="1711737896388108388">"Povolit od uživatele <xliff:g id="CALLER_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_mode_calls_summary_two" msgid="8476861928783654064">"Povolit od uživatelů <xliff:g id="CALLER_TYPE">%1$s</xliff:g> a <xliff:g id="CALLERT_TPYE">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="239685342222975733">"Pokud stejná osoba zavolá podruhé během <xliff:g id="MINUTES">%d</xliff:g> min"</string>
    <string name="zen_mode_behavior_summary_custom" msgid="168127313238020146">"Vlastní"</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Automaticky zapnout"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Nikdy"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Každou noc"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Pracovní dny (v noci)"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Čas zahájení"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Čas ukončení"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="4201521691238728701">"Následující den v <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="2061973221027570123">"Přepnout do režimu Pouze budíky na dobu neurčitou"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="6122003583875424601">
      <item quantity="few">Na <xliff:g id="DURATION">%1$d</xliff:g> minuty (tedy do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
      <item quantity="many">Na <xliff:g id="DURATION">%1$d</xliff:g> minuty (tedy do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
      <item quantity="other">Na <xliff:g id="DURATION">%1$d</xliff:g> minut (tedy do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
      <item quantity="one">Na minutu (tedy do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
    </plurals>
    <plurals name="zen_mode_summary_alarms_only_by_hour" formatted="false" msgid="2407703455581767748">
      <item quantity="few">Na <xliff:g id="DURATION">%1$d</xliff:g> hodiny (tedy do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
      <item quantity="many">Na <xliff:g id="DURATION">%1$d</xliff:g> hodiny (tedy do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
      <item quantity="other">Na <xliff:g id="DURATION">%1$d</xliff:g> hodin (tedy do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
      <item quantity="one">Na hodinu (tedy do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>) přepnout do režimu Pouze budíky</item>
    </plurals>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="7465525754879341907">"Přepnout do režimu Pouze budíky až do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="6172985102689237703">"Přejít do režimu Vždy vyrušit"</string>
    <string name="zen_mode_screen_on" msgid="8774571998575673502">"Když je obrazovka zapnutá"</string>
    <string name="zen_mode_screen_on_summary" msgid="2208664848367443505">"Povolit, aby při doručení oznámení v režimu Nerušit vyskočilo okno na obrazovce a zobrazila se ikona na stavovém řádku"</string>
    <string name="zen_mode_screen_off" msgid="3144446765110327937">"Když je vypnutá obrazovka"</string>
    <string name="zen_mode_screen_off_summary" msgid="7430034620565812258">"Povolit, aby se při doručení oznámení v režimu Nerušit zapínala obrazovka nebo blikala kontrolka"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="2826121465026642017">"Povolit, aby se při doručení oznámení v režimu Nerušit zapínala obrazovka"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Nastavení oznámení"</string>
    <string name="suggestion_button_text" msgid="3275010948381252006">"OK"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Odeslat zpětnou vazbu o tomto zařízení"</string>
    <string name="restr_pin_enter_admin_pin" msgid="1085834515677448072">"Zadejte PIN administrátora"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Zapnuto"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Vypnuto"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Připnutí obrazovky"</string>
    <string name="screen_pinning_description" msgid="1110847562111827766">"Pokud je toto nastavení zapnuto, lze připnout aktuální obrazovku a zajistit tak její zobrazení, dokud ji neodepnete.\n\nPostup připnutí obrazovky:\n\n1. Zkontrolujte, zda je funkce zapnutá.\n\n2. Otevřete Přehled.\n\n3. Klepněte na ikonu aplikace v horní části obrazovky a poté na Připnout."</string>
    <string name="screen_pinning_unlock_pattern" msgid="8282268570060313339">"Před uvolněním požádat o bezpečnostní gesto"</string>
    <string name="screen_pinning_unlock_pin" msgid="8757588350454795286">"Před uvolněním požádat o PIN"</string>
    <string name="screen_pinning_unlock_password" msgid="2514079566873826434">"Před uvolněním požádat o heslo"</string>
    <string name="screen_pinning_unlock_none" msgid="3814188275713871856">"Při uvolnění uzamknout zařízení"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2232461523882170874">"Tento pracovní profil je spravován pomocí aplikace:"</string>
    <string name="managing_admin" msgid="8843802210377459055">"Spravováno aplikací <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Experimentální)"</string>
    <string name="encryption_interstitial_header" msgid="468015813904595613">"Bezpečné spuštění"</string>
    <string name="encryption_continue_button" msgid="1121880322636992402">"Pokračovat"</string>
    <string name="encryption_interstitial_message_pin" msgid="2317181134653424679">"Toto zařízení můžete dále ochránit tím, že před jeho spuštěním bude požadován PIN. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků. \n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních. Má být před spuštěním zařízení vyžadován PIN?"</string>
    <string name="encryption_interstitial_message_pattern" msgid="7081249914068568570">"Toto zařízení můžete dále ochránit tím, že před jeho spuštěním bude požadováno gesto. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků. \n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních. Má být před spuštěním zařízení vyžadováno gesto?"</string>
    <string name="encryption_interstitial_message_password" msgid="7796567133897436443">"Toto zařízení můžete dále ochránit tím, že před jeho spuštěním bude požadováno heslo. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků. \n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních. Má být před spuštěním zařízení vyžadováno heslo?"</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="4550632760119547492">"Kromě odemykání otiskem prstu můžete toto zařízení dále ochránit tím, že před jeho spuštěním bude požadován PIN. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků.\n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních. Má být před spuštěním zařízení vyžadován PIN?"</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="932184823193006087">"Kromě odemykání otiskem prstu můžete toto zařízení dále ochránit tím, že před jeho spuštěním bude požadováno gesto. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků.\n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních. Má být před spuštěním zařízení vyžadováno gesto?"</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="5560954719370251702">"Kromě odemykání otiskem prstu můžete toto zařízení dále ochránit tím, že před jeho spuštěním bude požadováno heslo. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků.\n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních. Má být před spuštěním zařízení vyžadováno heslo?"</string>
    <string name="encryption_interstitial_message_pin_for_face" msgid="2017438765366716760">"Kromě odemykání pomocí obličeje můžete toto zařízení dále ochránit tím, že před jeho spuštěním bude požadován PIN. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků.\n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních. Má být před spuštěním zařízení vyžadován PIN?"</string>
    <string name="encryption_interstitial_message_pattern_for_face" msgid="3551827507967661552">"Kromě odemykání pomocí obličeje můžete toto zařízení dále ochránit tím, že před jeho spuštěním bude požadováno gesto. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků.\n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních. Má být před spuštěním zařízení vyžadováno gesto?"</string>
    <string name="encryption_interstitial_message_password_for_face" msgid="3452793542112093614">"Kromě odemykání pomocí obličeje můžete toto zařízení dále ochránit tím, že před jeho spuštěním bude požadováno heslo. Před spuštěním zařízení nemůže přijímat hovory, zprávy ani oznámení, včetně budíků.\n\nTato funkce pomáhá chránit data ve ztracených nebo ukradených zařízeních. Má být před spuštěním zařízení vyžadováno heslo?"</string>
    <string name="encryption_interstitial_yes" msgid="4439509435889513411">"Ano"</string>
    <string name="encryption_interstitial_no" msgid="8935031349097025137">"Ne"</string>
    <string name="restricted_true_label" msgid="4761453839409220473">"Omezené"</string>
    <string name="restricted_false_label" msgid="3279282180297058755">"Aplikace smí využívat baterii na pozadí"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"Požadovat kód PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"Požadovat gesto?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"Požadovat heslo?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="7582096542997635316">"Při zadávání kódu PIN ke spuštění zařízení ještě služby přístupnosti, jako je <xliff:g id="SERVICE">%1$s</xliff:g>, nebudou k dispozici."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="2020083142199612743">"Při zadávání gesta ke spuštění zařízení ještě služby přístupnosti, jako je <xliff:g id="SERVICE">%1$s</xliff:g>, nebudou k dispozici."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="4155875981789127796">"Při zadávání hesla ke spuštění zařízení ještě služby přístupnosti, jako je <xliff:g id="SERVICE">%1$s</xliff:g>, nebudou k dispozici."</string>
    <string name="direct_boot_unaware_dialog_message" msgid="2433632805847985867">"Poznámka: Pokud restartujete telefon a máte nastavený zámek obrazovky, tato aplikace se nespustí, dokud telefon neodemknete."</string>
    <string name="imei_information_title" msgid="8499085421609752290">"Informace o kódu IMEI"</string>
    <string name="imei_information_summary" msgid="2074095606556565233">"Informace související s kódem IMEI"</string>
    <string name="slot_number" msgid="3762676044904653577">"(Slot <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="1840761193189009248">"Otevírat ve výchozím nastavení"</string>
    <string name="app_launch_domain_links_title" msgid="1160925981363706090">"Otevírání odkazů"</string>
    <string name="app_launch_open_domain_urls_title" msgid="8914721351596745701">"Otevírání podporovaných odkazů"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="5367573364240712217">"Otevírat bez dotazu"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="8250695258211477480">"Podporované odkazy"</string>
    <string name="app_launch_other_defaults_title" msgid="2516812499807835178">"Další výchozí hodnoty"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"<xliff:g id="STORAGE_TYPE">%2$s</xliff:g> – využito <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="6042049833565674948">"Interní úložiště"</string>
    <string name="storage_type_external" msgid="7738894330670001898">"Externí úložiště"</string>
    <string name="data_summary_format" msgid="6213211533341068366">"Od <xliff:g id="DATE">%2$s</xliff:g> využito <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="storage_used" msgid="7128074132917008743">"Využití úložiště"</string>
    <string name="change" msgid="6657848623929839991">"Změnit"</string>
    <string name="change_storage" msgid="600475265207060436">"Změnit úložiště"</string>
    <string name="notifications_label" msgid="2872668710589600731">"Oznámení"</string>
    <string name="notifications_enabled" msgid="6983396130566021385">"Zapnuto"</string>
    <string name="notifications_enabled_with_info" msgid="5669544704839269901">"<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="1262114548434938079">"Vypnuto"</string>
    <string name="notifications_partly_blocked" msgid="592071133950126656">"<xliff:g id="COUNT_0">%1$d</xliff:g> z <xliff:g id="COUNT_1">%2$d</xliff:g> kategorií je vypnuto"</string>
    <string name="notifications_silenced" msgid="4728603513072110381">"Bez zvuku"</string>
    <string name="notifications_redacted" msgid="4493588975742803160">"Žádný citlivý obsah na obrazovce uzamčení"</string>
    <string name="notifications_hidden" msgid="3619610536038757468">"Ne na obrazovce uzamčení"</string>
    <string name="notifications_priority" msgid="1066342037602085552">"Režim Nerušit byl přepsán"</string>
    <string name="notifications_summary_divider" msgid="9013807608804041387">" / "</string>
    <string name="notification_summary_level" msgid="2726571692704140826">"Úroveň %d"</string>
    <string name="notification_summary_channel" msgid="5831124672372023524">"<xliff:g id="CHANNEL_NAME">%1$s</xliff:g> • <xliff:g id="GROUP_NAME">%2$s</xliff:g>"</string>
    <plurals name="notifications_categories_off" formatted="false" msgid="5583365573683409754">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategorie byly vypnuty</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> kategorie bylo vypnuto</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategorií bylo vypnuto</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> kategorie byla vypnuta</item>
    </plurals>
    <plurals name="permissions_summary" formatted="false" msgid="6402730318075959117">
      <item quantity="few">Udělena <xliff:g id="COUNT_1">%d</xliff:g> oprávnění</item>
      <item quantity="many">Uděleno <xliff:g id="COUNT_1">%d</xliff:g> oprávnění</item>
      <item quantity="other">Uděleno <xliff:g id="COUNT_1">%d</xliff:g> oprávnění</item>
      <item quantity="one">Uděleno <xliff:g id="COUNT_0">%d</xliff:g> oprávnění</item>
    </plurals>
    <plurals name="runtime_permissions_summary" formatted="false" msgid="1564663886246010959">
      <item quantity="few">Bylo uděleno <xliff:g id="COUNT_2">%d</xliff:g> z <xliff:g id="COUNT_3">%d</xliff:g> oprávnění</item>
      <item quantity="many">Bylo uděleno <xliff:g id="COUNT_2">%d</xliff:g> z <xliff:g id="COUNT_3">%d</xliff:g> oprávnění</item>
      <item quantity="other">Bylo uděleno <xliff:g id="COUNT_2">%d</xliff:g> z <xliff:g id="COUNT_3">%d</xliff:g> oprávnění</item>
      <item quantity="one">Bylo uděleno <xliff:g id="COUNT_0">%d</xliff:g> z <xliff:g id="COUNT_1">%d</xliff:g> oprávnění</item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="931276038884210752">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> další oprávnění</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> dalšího oprávnění</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> dalších oprávnění</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> další oprávnění</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="1679758182657005375">"Nebyla udělena žádná oprávnění"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7655100570513818534">"Nevyžaduje žádná oprávnění"</string>
    <string name="filter_all_apps" msgid="1988403195820688644">"Všechny aplikace"</string>
    <string name="filter_enabled_apps" msgid="5395727306799456250">"Nainstalované aplikace"</string>
    <string name="filter_instant_apps" msgid="574277769963965565">"Okamžité aplikace"</string>
    <string name="filter_personal_apps" msgid="3277727374174355971">"Osobní"</string>
    <string name="filter_work_apps" msgid="24519936790795574">"Práce"</string>
    <string name="filter_notif_all_apps" msgid="2299049859443680242">"Aplikace: Vše"</string>
    <string name="filter_notif_blocked_apps" msgid="3383043508771300704">"Vypnuto"</string>
    <string name="filter_notif_urgent_channels" msgid="3972473613117159653">"Kategorie: Urgentní důležitost"</string>
    <string name="filter_notif_low_channels" msgid="4128487387390004604">"Kategorie: Nízká důležitost"</string>
    <string name="filter_notif_blocked_channels" msgid="5880190882221644289">"Kategorie: Vypnuto"</string>
    <string name="filter_notif_dnd_channels" msgid="1817930848881696728">"Kategorie: Přepíše „Nerušit“"</string>
    <string name="advanced_apps" msgid="4812975097124803873">"Rozšířená nastavení"</string>
    <string name="configure_apps" msgid="6685680790825882528">"Konfigurace aplikací"</string>
    <string name="unknown_app" msgid="5275921288718717656">"Neznámá aplikace"</string>
    <string name="app_permissions" msgid="5584182129908141622">"Správce oprávnění"</string>
    <string name="app_permissions_summary" msgid="5163974162150406324">"Aplikace, které používají oprávnění <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="tap_to_wake" msgid="7211944147196888807">"Probudit klepnutím"</string>
    <string name="tap_to_wake_summary" msgid="4341387904987585616">"Dvojitým klepnutím kamkoli na obrazovku zařízení probudíte"</string>
    <string name="domain_urls_title" msgid="3132983644568821250">"Otevírání odkazů"</string>
    <string name="domain_urls_summary_none" msgid="2639588015479657864">"Neotevírat podporované odkazy"</string>
    <string name="domain_urls_summary_one" msgid="3704934031930978405">"Otevírat adresy z domény <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="3950089361819428455">"Otevřít doménu <xliff:g id="DOMAIN">%s</xliff:g> a další adresy URL"</string>
    <string name="domain_urls_apps_summary_off" msgid="1833056772600031220">"Není k dispozici žádná aplikace k otevírání podporovaných odkazů"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="240214361240709399">
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikace k otevírání podporovaných odkazů</item>
      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> aplikace k otevírání podporovaných odkazů</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikace k otevírání podporovaných odkazů</item>
      <item quantity="one">Jedna aplikace k otevírání podporovaných odkazů</item>
    </plurals>
    <string name="app_link_open_always" msgid="2474058700623948148">"Otevírat v této aplikaci"</string>
    <string name="app_link_open_ask" msgid="7800878430190575991">"Pokaždé se zeptat"</string>
    <string name="app_link_open_never" msgid="3407647600352398543">"Neotevírat v této aplikaci"</string>
    <string name="default_apps_title" msgid="1660450272764331490">"Výchozí"</string>
    <string name="default_for_work" msgid="9152194239366247932">"Výchozí pracovní"</string>
    <string name="assist_and_voice_input_title" msgid="1733165754793221197">"Asistence a hlasové zadávání"</string>
    <string name="default_assist_title" msgid="8868488975409247921">"Asistenční aplikace"</string>
    <string name="assistant_security_warning_title" msgid="8673079231955467177">"Chcete <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> nastavit jako svého asistenta?"</string>
    <string name="assistant_security_warning" msgid="8498726261327239136">"Asistent bude moci číst informace o aplikacích používaných v systému, včetně údajů viditelných na obrazovce a přístupných v rámci aplikací."</string>
    <string name="assistant_security_warning_agree" msgid="7710290206928033908">"Souhlasím"</string>
    <string name="assistant_security_warning_disagree" msgid="877419950830205913">"Nesouhlasím"</string>
    <string name="choose_voice_input_title" msgid="975471367067718019">"Zvolte metodu hlasového zadávání"</string>
    <string name="default_browser_title" msgid="8101772675085814670">"Prohlížeč"</string>
    <string name="default_browser_title_none" msgid="2124785489953628553">"Žádný výchozí prohlížeč"</string>
    <string name="default_phone_title" msgid="282005908059637350">"Aplikace na telefonování"</string>
    <string name="roles_title" msgid="8739481762225637569">"Role"</string>
    <string name="default_app" msgid="6864503001385843060">"(Výchozí)"</string>
    <string name="system_app" msgid="9068313769550747372">"(Systém)"</string>
    <string name="system_default_app" msgid="3091113402349739037">"(Výchozí nastavení systému)"</string>
    <string name="apps_storage" msgid="4353308027210435513">"Úložiště aplikací"</string>
    <string name="usage_access" msgid="5479504953931038165">"Přístup k údajům o využití"</string>
    <string name="permit_usage_access" msgid="4012876269445832300">"Povolit přístup k údajům o využití"</string>
    <string name="app_usage_preference" msgid="7065701732733134991">"Nastavení využití aplikací"</string>
    <string name="time_spent_in_app_pref_title" msgid="9124796405314626532">"Čas strávený na zařízení"</string>
    <string name="usage_access_description" msgid="1352111094596416795">"Přístup k údajům o využití umožňuje aplikaci sledovat, které ostatní aplikace používáte, jak často je používáte, jakého máte operátora, nastavení jazyka a další podrobnosti."</string>
    <string name="memory_settings_title" msgid="7490541005204254222">"Paměť"</string>
    <string name="memory_details_title" msgid="8542565326053693320">"Podrobnosti o paměti"</string>
    <string name="always_running" msgid="6042448320077429656">"Vždy spuštěno (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="6611250683037700864">"Spuštěno občas (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="348413460168817458">"Spuštěno výjimečně (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="6874803757715963097">"Maximum"</string>
    <string name="memory_avg_use" msgid="7382015389130622870">"Průměr"</string>
    <string name="memory_max_desc" msgid="2861832149718335864">"Maximálně <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="1551240906596518412">"Průměrně <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_use_running_format" msgid="4172488041800743760">"<xliff:g id="MEMORY">%1$s</xliff:g> / <xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="77905604092541454">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="3459065925679828230">"Optimalizace výdrže bat."</string>
    <string name="additional_battery_info" msgid="4754099329165411970">"Upozornění na využití"</string>
    <string name="show_all_apps" msgid="1512506948197818534">"Zobrazit úplné využití zařízení"</string>
    <string name="hide_extra_apps" msgid="5016497281322459633">"Zobrazit využití aplikací"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="467347882627862744">
      <item quantity="few"><xliff:g id="NUMBER">%2$d</xliff:g> aplikace se chovají neobvykle</item>
      <item quantity="many"><xliff:g id="NUMBER">%2$d</xliff:g> aplikace se chová neobvykle</item>
      <item quantity="other"><xliff:g id="NUMBER">%2$d</xliff:g> aplikací se chová neobvykle</item>
      <item quantity="one">Aplikace <xliff:g id="APP">%1$s</xliff:g> se chová neobvykle</item>
    </plurals>
    <plurals name="power_high_usage_title" formatted="false" msgid="3826660033363082922">
      <item quantity="few">Aplikace vybíjejí baterii</item>
      <item quantity="many">Aplikace vybíjejí baterii</item>
      <item quantity="other">Aplikace vybíjejí baterii</item>
      <item quantity="one">Aplikace <xliff:g id="APP">%1$s</xliff:g> vybíjí baterii</item>
    </plurals>
    <string name="high_power_filter_on" msgid="3222265297576680099">"Neoptimalizováno"</string>
    <string name="high_power_on" msgid="6216293998227583810">"Neoptimalizováno"</string>
    <string name="high_power_off" msgid="3393904131961263278">"Optimalizace využívání baterie"</string>
    <string name="high_power_system" msgid="7362862974428225301">"Optimalizace výdrže baterie není k dispozici"</string>
    <string name="high_power_desc" msgid="6283926163708585760">"Optimalizace výdrže baterie nebude použita. Baterie se může vybíjet rychleji."</string>
    <string name="high_power_prompt_title" msgid="6358673688590282655">"Povolit aplikaci stále běžet na pozadí?"</string>
    <string name="high_power_prompt_body" msgid="1031422980602565049">"Pokud aplikaci <xliff:g id="APP_NAME">%1$s</xliff:g> povolíte stále běžet na pozadí, může to zkrátit životnost baterie. \n\nToto nastavení můžete později změnit v sekci Nastavení &gt; Aplikace a oznámení."</string>
    <string name="battery_summary" msgid="8044042095190688654">"Od posledního úplného nabití bylo využito <xliff:g id="PERCENTAGE">%1$s</xliff:g> baterie"</string>
    <string name="battery_power_management" msgid="5571519699679107523">"Správa napájení"</string>
    <string name="no_battery_summary" msgid="3528036835462846814">"Baterie od posledního úplného nabití nebyla využita"</string>
    <string name="app_notification_preferences" msgid="1599319335092722613">"Nastavení aplikace"</string>
    <string name="system_ui_settings" msgid="579824306467081123">"Zobrazit tuner SystemUI"</string>
    <string name="additional_permissions" msgid="6463784193877056080">"Další oprávnění"</string>
    <string name="additional_permissions_more" msgid="3538612272673191451">"Počet: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1124840737776588602">"Sdílet zprávu o chybě?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4973886976504823801">"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="3495929560689435496">"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="5859287696666024466">"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="532226159318779397">"Sdílet"</string>
    <string name="decline_remote_bugreport_action" msgid="518720235407565134">"Odmítnout"</string>
    <string name="usb_use_charging_only" msgid="4800495064747543954">"Žádný přenos dat"</string>
    <string name="usb_use_charging_only_desc" msgid="3066256793008540627">"Nabít jen toto zařízení"</string>
    <string name="usb_use_power_only" msgid="3236391691786786070">"Nabíjení připojeného zařízení"</string>
    <string name="usb_use_file_transfers" msgid="1223134119354320726">"Přenos souborů"</string>
    <string name="usb_use_file_transfers_desc" msgid="4235764784331804488">"Přenos souborů do jiného zařízení"</string>
    <string name="usb_use_photo_transfers" msgid="8192719651229326283">"PTP"</string>
    <string name="usb_use_photo_transfers_desc" msgid="2963034811151325996">"Přenést fotky nebo soubory, pokud MTP není podporováno (PTP)"</string>
    <string name="usb_use_tethering" msgid="3944506882789422118">"Tethering přes USB"</string>
    <string name="usb_use_MIDI" msgid="5116404702692483166">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="8473936990076693175">"Toto zařízení se použije v režimu MIDI"</string>
    <string name="usb_use" msgid="3372728031108932425">"Použití USB:"</string>
    <string name="usb_default_label" msgid="2211094045594574774">"Výchozí konfigurace USB"</string>
    <string name="usb_default_info" msgid="8864535445796200695">"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_pref" msgid="1400617804525116158">"USB"</string>
    <string name="usb_preference" msgid="7394265019817945275">"Předvolby USB"</string>
    <string name="usb_control_title" msgid="4404322722995917160">"USB ovládá:"</string>
    <string name="usb_control_host" msgid="2276710819046647200">"Připojené zařízení"</string>
    <string name="usb_control_device" msgid="5821511964163469463">"Toto zařízení"</string>
    <string name="usb_switching" msgid="8995313698715545619">"Přepínání..."</string>
    <string name="usb_switching_failed" msgid="4156073015692409651">"Nelze přepnout"</string>
    <string name="usb_summary_charging_only" msgid="7544327009143659751">"Nabíjení zařízení"</string>
    <string name="usb_summary_power_only" msgid="1996391096369798526">"Nabíjení připojeného zařízení"</string>
    <string name="usb_summary_file_transfers" msgid="6925168380589489645">"Přenos souborů"</string>
    <string name="usb_summary_tether" msgid="951190049557074535">"Tethering přes USB"</string>
    <string name="usb_summary_photo_transfers" msgid="665584667685030007">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2399066753961085360">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="7700800611455849806">"Přenos souborů a energie k nabíjení"</string>
    <string name="usb_summary_tether_power" msgid="5825335393952752238">"Tethering přes USB a energie k nabíjení"</string>
    <string name="usb_summary_photo_transfers_power" msgid="6826058111908423069">"PTP a energie k nabíjení"</string>
    <string name="usb_summary_MIDI_power" msgid="3308250484012677596">"MIDI a energie k nabíjení"</string>
    <string name="background_check_pref" msgid="7550258400138010979">"Kontrola pozadí"</string>
    <string name="background_check_title" msgid="4534254315824525593">"Úplný přístup k pozadí"</string>
    <string name="assist_access_context_title" msgid="2269032346698890257">"Použití textu z obrazovky"</string>
    <string name="assist_access_context_summary" msgid="1991421283142279560">"Asistenční aplikace bude mít přístup k obsahu obrazovky v textové podobě"</string>
    <string name="assist_access_screenshot_title" msgid="4034721336291215819">"Použití snímku obrazovky"</string>
    <string name="assist_access_screenshot_summary" msgid="6761636689013259901">"Asistenční aplikace bude mít přístup k obrazu na obrazovce"</string>
    <string name="assist_flash_title" msgid="506661221230034891">"Zablikání obrazovky"</string>
    <string name="assist_flash_summary" msgid="9160668468824099262">"Když asistenční aplikace na obrazovce nebo snímku obrazovky narazí na text, okraje obrazovky zablikají"</string>
    <string name="assist_footer" msgid="1982791172085896864">"Asistenční aplikace vám může pomoci na základě informací na zobrazené obrazovce. Některé aplikace podporují Launcher i hlasový vstup a nabízejí integrovanou asistenci."</string>
    <string name="average_memory_use" msgid="829566450150198512">"Průměrné využití paměti"</string>
    <string name="maximum_memory_use" msgid="7493720799710132496">"Maximální využití paměti"</string>
    <string name="memory_usage" msgid="1781358557214390033">"Využití paměti"</string>
    <string name="app_list_memory_use" msgid="6987417883876419338">"Využití aplikací"</string>
    <string name="memory_details" msgid="5943436005716991782">"Podrobnosti"</string>
    <string name="memory_use_summary" msgid="5608257211903075754">"Za poslední 3 hodiny bylo v průměru využito <xliff:g id="SIZE">%1$s</xliff:g> paměti."</string>
    <string name="no_memory_use_summary" msgid="2016900536806235588">"Za poslední 3 hodiny nebyla využita žádná paměť."</string>
    <string name="sort_avg_use" msgid="3998036180505143129">"Řadit podle prům. využití"</string>
    <string name="sort_max_use" msgid="4629247978290075124">"Řadit podle max. využití"</string>
    <string name="memory_performance" msgid="5661005192284103281">"Výkon"</string>
    <string name="total_memory" msgid="2017287600738630165">"Celková paměť"</string>
    <string name="average_used" msgid="5338339266517245782">"Průměrně použito (%)"</string>
    <string name="free_memory" msgid="4003936141603549746">"Volná"</string>
    <string name="memory_usage_apps" msgid="5650192998273294098">"Paměť používaná aplikacemi"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="6089210945574265774">
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikace použily paměť během posledních <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="many"><xliff:g id="COUNT">%1$d</xliff:g> aplikace použilo paměť během posledních <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikací použilo paměť během posledních <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="one">1 aplikace použila paměť během posledních <xliff:g id="DURATION_0">%2$s</xliff:g></item>
    </plurals>
    <string name="running_frequency" msgid="6622624669948277693">"Frekvence"</string>
    <string name="memory_maximum_usage" msgid="6513785462055278341">"Maximální využití"</string>
    <string name="no_data_usage" msgid="9131454024293628063">"Nebyla využita žádná data"</string>
    <string name="zen_access_warning_dialog_title" msgid="1198189958031157142">"Povolit aplikaci <xliff:g id="APP">%1$s</xliff:g> přístup k režimu Nerušit?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="4015885767653010873">"Aplikace bude moci zapínat a vypínat režim Nerušit a měnit související nastavení."</string>
    <string name="zen_access_disabled_package_warning" msgid="302820100078584431">"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="558779234015793950">"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="5518216907304930148">"Všechna pravidla pro režim Nerušit vytvořená touto aplikací budou odstraněna."</string>
    <string name="ignore_optimizations_on" msgid="6915689518016285116">"Neoptimalizovat"</string>
    <string name="ignore_optimizations_off" msgid="6153196256410296835">"Optimalizovat"</string>
    <string name="ignore_optimizations_on_desc" msgid="3549930955839111652">"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="5255731062045426544">"Doporučeno k zajištění delší výdrže baterie"</string>
    <string name="ignore_optimizations_title" msgid="2829637961185027768">"Chcete aplikaci <xliff:g id="APP">%s</xliff:g> povolit ignorování optimalizace využití baterie?"</string>
    <string name="app_list_preference_none" msgid="108006867520327904">"Žádné"</string>
    <string name="work_profile_usage_access_warning" msgid="2918050775124911939">"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="accessibility_lock_screen_progress" msgid="2408292742980383166">"Použité znaky: <xliff:g id="COUNT_0">%1$d</xliff:g> z <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="draw_overlay" msgid="6564116025404257047">"Zobrazit přes ostatní aplikace"</string>
    <string name="system_alert_window_settings" msgid="8466613169103527868">"Zobrazit přes ostatní aplikace"</string>
    <string name="system_alert_window_apps_title" msgid="7005760279028569491">"Aplikace"</string>
    <string name="system_alert_window_access_title" msgid="6297115362542361241">"Zobrazit přes ostatní aplikace"</string>
    <string name="permit_draw_overlay" msgid="7456536798718633432">"Povolit zobrazení přes jiné aplikace"</string>
    <string name="allow_overlay_description" msgid="8961670023925421358">"Umožní této aplikaci zobrazovat se přes ostatní aplikace, které používáte. Může tak narušit vaši práci s těmito aplikacemi a změnit způsob jejich zobrazování nebo chování."</string>
    <string name="keywords_vr_listener" msgid="7441221822576384680">"VR virtuální realita přijímač stereo pomocná služba"</string>
    <string name="keywords_system_alert_window" msgid="5049498015597864850">"systém upozornění okno dialog zobrazení nad jinými aplikacemi"</string>
    <string name="overlay_settings" msgid="6930854109449524280">"Zobrazit přes ostatní aplikace"</string>
    <string name="system_alert_window_summary" msgid="602892301318324492">"Aplikace s povolením k zobrazení přes ostatní aplikace: <xliff:g id="COUNT_0">%1$d</xliff:g> z <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="filter_overlay_apps" msgid="6965969283342557573">"Aplikace s oprávněním"</string>
    <string name="app_permission_summary_allowed" msgid="1505409933012886711">"Povoleno"</string>
    <string name="app_permission_summary_not_allowed" msgid="2592617058101882802">"Nepovoleno"</string>
    <string name="keywords_install_other_apps" msgid="761078076051006558">"instalace aplikace neznámé zdroje"</string>
    <string name="write_settings" msgid="4797457275727195681">"Změny nastavení systému"</string>
    <string name="keywords_write_settings" msgid="6415597272561105138">"zápis a změna nastavení systému"</string>
    <string name="write_settings_summary" msgid="4302268998611412696">"Aplikace, které mohou měnit nastavení systému: <xliff:g id="COUNT_0">%1$d</xliff:g> z <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="financial_apps_sms_access_title" msgid="762694352017728050">"Finanční aplikace – přístup k SMS"</string>
    <string name="filter_install_sources_apps" msgid="3102976274848199118">"Lze nainstalovat jiné aplikace"</string>
    <string name="filter_write_settings_apps" msgid="2914615026197322551">"Smí měnit nastavení systému"</string>
    <string name="write_settings_title" msgid="4232152481902542284">"Smí měnit nastavení systému"</string>
    <string name="write_system_settings" msgid="3482913590601096763">"Změny nastavení systému"</string>
    <string name="permit_write_settings" msgid="658555006453212691">"Povolit úpravy nastavení systému"</string>
    <string name="write_settings_description" msgid="6868293938839954623">"Toto oprávnění umožňuje aplikaci měnit nastavení systému."</string>
    <string name="write_settings_on" msgid="8230580416068832239">"Ano"</string>
    <string name="write_settings_off" msgid="5156104383386336233">"Ne"</string>
    <string name="external_source_switch_title" msgid="3621381992793251070">"Povolit z tohoto zdroje"</string>
    <string name="camera_gesture_title" msgid="1075838577642393011">"Otevření Fotoaparátu otočením zápěstí"</string>
    <string name="camera_gesture_desc" msgid="1831390075255870960">"Umožňuje otevřít aplikaci Fotoaparát dvojitým otočením zápěstí."</string>
    <string name="camera_double_tap_power_gesture_title" msgid="1651873760405034645">"Fotoaparát dvojitým stisknutím vypínače"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="7355664631775680376">"Rychle otevře fotoaparát bez odemknutí obrazovky"</string>
    <string name="screen_zoom_title" msgid="5233515303733473927">"Zobrazovaná velikost"</string>
    <string name="screen_zoom_short_summary" msgid="7291960817349834688">"Umožňuje zvětšit nebo zmenšit položky na obrazovce"</string>
    <string name="screen_zoom_keywords" msgid="9176477565403352552">"displej, hustota, přiblížení obrazovky, měřítko, zvětšení"</string>
    <string name="screen_zoom_summary" msgid="6445488991799015407">"Umožňuje zvětšit nebo zmenšit položky na obrazovce. Ikony některých aplikací na ploše se mohou přemístit."</string>
    <string name="screen_zoom_preview_title" msgid="4680671508172336572">"Náhled"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="4622359904253364742">"Zmenšit"</string>
    <string name="screen_zoom_make_larger_desc" msgid="2236171043607896594">"Zvětšit"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="8443032489384985820">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="998709701837681129">"H"</string>
    <string name="screen_zoom_conversation_message_1" msgid="6546951024984852686">"Ahoj Honzo!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6935424214137738647">"Půjdeme dnes na kafe?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="5218221201861387402">"Tak jo. Znám poblíž dobrý podnik."</string>
    <string name="screen_zoom_conversation_message_4" msgid="5564676794767555447">"Super!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="7453710416319650556">"Út 18:00"</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="7107225702890747588">"Út 18:01"</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="3785674344762707688">"Út 18:02"</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2511469395448561259">"Út 18:03"</string>
    <string name="disconnected" msgid="4836600637485526329">"Nepřipojeno"</string>
    <string name="keyboard_disconnected" msgid="1495037256967224035">"Nepřipojeno"</string>
    <string name="data_usage_summary_format" msgid="7507047900192160585">"Využití dat: <xliff:g id="AMOUNT">%1$s</xliff:g>"</string>
    <string name="data_usage_wifi_format" msgid="5417296451392612860">"Přes Wi-Fi použito <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <plurals name="notification_summary" formatted="false" msgid="3941492005316143599">
      <item quantity="few">Vypnuto pro <xliff:g id="COUNT">%d</xliff:g> aplikace</item>
      <item quantity="many">Vypnuto pro <xliff:g id="COUNT">%d</xliff:g> aplikace</item>
      <item quantity="other">Vypnuto pro <xliff:g id="COUNT">%d</xliff:g> aplikací</item>
      <item quantity="one">Vypnuto pro 1 aplikaci</item>
    </plurals>
    <string name="notification_summary_none" msgid="4586376436702610">"Zapnuto pro všechny aplikace"</string>
    <string name="apps_summary" msgid="193158055537070092">"Nainstalované aplikace: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="apps_summary_example" msgid="2118896966712746139">"Nainstalované aplikace: 24"</string>
    <string name="storage_summary" msgid="3801281635351732202">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> využito – <xliff:g id="FREE_SPACE">%2$s</xliff:g> volné"</string>
    <string name="storage_summary_with_sdcard" msgid="3290457009629490121">"Interní úložiště: 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_summary" msgid="6737806235882127328">"Po <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> nečinnosti přejít do režimu spánku"</string>
    <string name="display_dashboard_summary" msgid="4145888780290131488">"Tapeta, režim spánku, velikost písma"</string>
    <string name="display_dashboard_summary_with_style" msgid="870920274423314524">"Styly, tapety, časový limit obrazovky, velikost písma"</string>
    <string name="display_dashboard_nowallpaper_summary" msgid="7840559323355210111">"Režim spánku, velikost písma"</string>
    <string name="display_summary_example" msgid="9102633726811090523">"Po 10 minutách nečinnosti přejít do režimu spánku"</string>
    <string name="memory_summary" msgid="8080825904671961872">"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="1674864467098487328">"Jste přihlášeni jako <xliff:g id="USER_NAME">%1$s</xliff:g>."</string>
    <string name="payment_summary" msgid="3472482669588561110">"<xliff:g id="APP_NAME">%1$s</xliff:g> – nastaveno jako výchozí"</string>
    <string name="backup_disabled" msgid="485189128759595412">"Zálohování bylo zakázáno"</string>
    <string name="android_version_summary" msgid="2935995161657697278">"Aktualizováno na Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="487831391976523090">"K dispozici je aktualizace"</string>
    <string name="disabled_by_policy_title" msgid="627023216027648534">"Akce není povolena."</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="3208724801293696486">"Hlasitost nelze změnit"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="7919816644946067058">"Volání není povoleno"</string>
    <string name="disabled_by_policy_title_sms" msgid="5733307423899610340">"Zprávy SMS nejsou povoleny"</string>
    <string name="disabled_by_policy_title_camera" msgid="6225008536855644874">"Použití fotoaparátu není povoleno"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="4066913623298047094">"Uložení snímku obrazovky není povoleno"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="7872038990805477554">"Tuto aplikaci nelze otevřít"</string>
    <string name="default_admin_support_msg" msgid="4489678214035485367">"Máte-li nějaké otázky, obraťte se na svého administrátora IT"</string>
    <string name="admin_support_more_info" msgid="8901377038510512654">"Další podrobnosti"</string>
    <string name="admin_profile_owner_message" msgid="5860816886981109626">"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="3842630535450382172">"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="6232893638259790789">"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="condition_turn_off" msgid="1960945836880080298">"Vypnout"</string>
    <string name="condition_turn_on" msgid="9089876276117874591">"Zapnout"</string>
    <string name="condition_expand_show" msgid="608202020023489939">"Zobrazit"</string>
    <string name="condition_expand_hide" msgid="948507739223760667">"Skrýt"</string>
    <string name="condition_hotspot_title" msgid="5959815393203320845">"Hotspot je aktivní"</string>
    <string name="condition_airplane_title" msgid="287356299107070503">"Režim Letadlo je zapnutý"</string>
    <string name="condition_airplane_summary" msgid="2500054042183138980">"Sítě nejsou k dispozici"</string>
    <string name="condition_zen_title" msgid="2897779738211625">"Režim Nerušit je zapnutý"</string>
    <string name="condition_zen_summary_phone_muted" msgid="3644614024467141806">"Telefon je ztlumen"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="4047564276599301064">"S výjimkami"</string>
    <string name="condition_battery_title" msgid="3272131008388575349">"Spořič baterie je zapnutý"</string>
    <string name="condition_battery_summary" msgid="5847532902924566572">"Omezené funkce"</string>
    <string name="condition_cellular_title" msgid="1327317003797575735">"Mobilní data jsou vypnuta"</string>
    <string name="condition_cellular_summary" msgid="816822977403022625">"Internet je k dispozici jen přes Wi-Fi"</string>
    <string name="condition_bg_data_title" msgid="5475793236997935138">"Spořič dat"</string>
    <string name="condition_bg_data_summary" msgid="1852811387315557164">"Omezené funkce"</string>
    <string name="condition_work_title" msgid="7293722361184366648">"Pracovní profil je vypnutý"</string>
    <string name="condition_work_summary" msgid="9167580982244020746">"Pro aplikace a oznámení"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4930240942726349213">"Zapnout zvuk"</string>
    <string name="condition_device_muted_title" msgid="3476439379918599716">"Vyzvánění bylo ztlumeno"</string>
    <string name="condition_device_muted_summary" msgid="6313274406443663781">"Volání a oznámení"</string>
    <string name="condition_device_vibrate_title" msgid="8070177546359590131">"Pouze vibrace"</string>
    <string name="condition_device_vibrate_summary" msgid="5743200564646910423">"Volání a oznámení"</string>
    <string name="night_display_suggestion_title" msgid="6602129097059325291">"Nastavení plánu nočního režimu"</string>
    <string name="night_display_suggestion_summary" msgid="228346372178218442">"Každý večer automaticky zbarvit obrazovku do oranžova"</string>
    <string name="condition_night_display_title" msgid="5599814941976856183">"Noční režim je aktivní"</string>
    <string name="condition_night_display_summary" msgid="7150932917610919907">"Tónování obrazovky do jantarové"</string>
    <string name="condition_grayscale_title" msgid="3426050703427823519">"Zešednutí obrazovky"</string>
    <string name="condition_grayscale_summary" msgid="7652835784223724625">"Displej pouze v šedé barvě"</string>
    <string name="homepage_condition_footer_content_description" msgid="2335918927419018030">"Sbalit"</string>
    <string name="suggestions_title_v2" msgid="5601181602924147569">"Navrženo pro vás"</string>
    <string name="suggestions_title" msgid="7280792342273268377">"Návrhy"</string>
    <string name="suggestions_summary" msgid="2509040178581728056">"+<xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="8223690393059519879">"a další (<xliff:g id="ID_1">%1$d</xliff:g>)"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="1857433444865249823">
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> návrhy</item>
      <item quantity="many"><xliff:g id="COUNT">%1$d</xliff:g> návrhu</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> návrhů</item>
      <item quantity="one">1 návrh</item>
    </plurals>
    <plurals name="suggestions_collapsed_summary" formatted="false" msgid="7680263825371165461">
      <item quantity="few">a <xliff:g id="COUNT">%1$d</xliff:g> návrhy</item>
      <item quantity="many">a <xliff:g id="COUNT">%1$d</xliff:g> návrhu</item>
      <item quantity="other">a <xliff:g id="COUNT">%1$d</xliff:g> návrhů</item>
      <item quantity="one">a 1 návrh</item>
    </plurals>
    <string name="suggestion_remove" msgid="904627293892092439">"Odstranit"</string>
    <string name="color_temperature" msgid="2070126836910615605">"Studené barvy"</string>
    <string name="color_temperature_desc" msgid="4793729830226404052">"Použijí se studenější barvy zobrazení"</string>
    <string name="color_temperature_toast" msgid="4974218172133854827">"Chcete-li změnu barev použít, vypněte obrazovku"</string>
    <string name="camera_laser_sensor_switch" msgid="8913588990743234440">"Laserový senzor fotoaparátu"</string>
    <string name="ota_disable_automatic_update" msgid="2319639631655915050">"Automatické aktualizace systému"</string>
    <string name="ota_disable_automatic_update_summary" msgid="940729694354373087">"Nainstalovat aktualizace po restartu zařízení"</string>
    <string name="usage" msgid="2977875522080448986">"Využití"</string>
    <string name="cellular_data_usage" msgid="2155683719898158203">"Využití mobilních dat"</string>
    <string name="app_cellular_data_usage" msgid="5468472735806533448">"Využití dat aplikací"</string>
    <string name="wifi_data_usage" msgid="771603760674507659">"Využití dat přes Wi-Fi"</string>
    <string name="ethernet_data_usage" msgid="5108764537574354616">"Využití dat přes ethernet"</string>
    <string name="wifi" msgid="1081550856200013637">"Wi-Fi"</string>
    <string name="ethernet" msgid="6600095783781389720">"Ethernet"</string>
    <string name="cell_data_template" msgid="405684854174361041">"Mobilní data: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="wifi_data_template" msgid="6265570748799357386">"Data přes Wi-Fi: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="ethernet_data_template" msgid="5782476509881033590">"Data přes ethernet: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="billing_cycle" msgid="6614597736285325497">"Limit dat a upozornění"</string>
    <string name="app_usage_cycle" msgid="8877223251648092131">"Cyklus využití dat aplikacemi"</string>
    <string name="cell_data_warning" msgid="1985956818884847057">"Upozornění na data: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="1578367585799358854">"Limit dat <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="6888825370687743208">"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="billing_cycle_fragment_summary" msgid="8231066353654583106">"Měsíčně (<xliff:g id="ID_1">%1$s</xliff:g>. den)"</string>
    <string name="network_restrictions" msgid="8234695294536675380">"Omezení sítě"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="4301618027244595839">
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> omezení</item>
      <item quantity="many"><xliff:g id="COUNT">%1$d</xliff:g> omezení</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> omezení</item>
      <item quantity="one">1 omezení</item>
    </plurals>
    <string name="operator_warning" msgid="1862988028996859195">"Operátor může data počítat jinak než zařízení"</string>
    <string name="data_used_template" msgid="3245919669966296505">"Využito <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="6115364758236594593">"Nastavit upozornění na data"</string>
    <string name="data_warning" msgid="209133958008062117">"Upozornění na data"</string>
    <string name="data_warning_footnote" msgid="776341964125603711">"Upozornění ohledně dat a limit dat měří zařízení. Údaje se od údajů operátora mohou lišit."</string>
    <string name="set_data_limit" msgid="2901526323210516923">"Nastavit limit dat"</string>
    <string name="data_limit" msgid="1885406964934590552">"Limit dat"</string>
    <string name="data_usage_template" msgid="2923744765873163859">"<xliff:g id="ID_1">%1$s</xliff:g> využito v období <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1029654422228677273">"Konfigurovat"</string>
    <string name="data_usage_other_apps" msgid="3272872663517382050">"Ostatní aplikace zahrnuté do využití"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="2635267833484232703">
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikace mají povoleno využívat neomezená data, i když je zapnutý spořič dat</item>
      <item quantity="many"><xliff:g id="COUNT">%1$d</xliff:g> aplikace má povoleno využívat neomezená data, i když je zapnutý spořič dat</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikací má povoleno využívat neomezená data, i když je zapnutý spořič dat</item>
      <item quantity="one">1 aplikace má povoleno využívat neomezená data, i když je zapnutý spořič dat</item>
    </plurals>
    <string name="data_usage_title" msgid="3659356290392241789">"Primární data"</string>
    <string name="data_usage_wifi_title" msgid="7063659423081820720">"Data přes Wi‑Fi"</string>
    <string name="data_used" msgid="5116389957228457203">"Využito <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_used_formatted" msgid="2989129931961311051">"Využito <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="1134445012475270295">"<xliff:g id="ID_1">^1</xliff:g> nad limit"</string>
    <string name="data_remaining" msgid="8998091725895502181">"Zbývající čas: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="456503215317213651">
      <item quantity="few">Zbývají %d dny</item>
      <item quantity="many">Zbývá %d dne</item>
      <item quantity="other">Zbývá %d dní</item>
      <item quantity="one">Zbývá %d den</item>
    </plurals>
    <string name="billing_cycle_none_left" msgid="5892754995098583472">"Nezbývá žádný čas"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="825838050296069404">"Zbývá méně než 1 den"</string>
    <string name="carrier_and_update_text" msgid="7963409972475063897">"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="3277403390316201982">"Aktualizováno před <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="4057997726060106722">"Aktualizováno operátorem <xliff:g id="ID_1">^1</xliff:g> teď"</string>
    <string name="no_carrier_update_now_text" msgid="1766859656868932996">"Aktualizováno teď"</string>
    <string name="launch_mdp_app_text" msgid="6751296320061773169">"Zobrazit tarif"</string>
    <string name="launch_wifi_text" msgid="2311424914664372687">"Zobrazit podrobnosti"</string>
    <string name="data_saver_title" msgid="8034286939200289826">"Spořič dat"</string>
    <string name="unrestricted_data_saver" msgid="952796077540228711">"Neomezená data"</string>
    <string name="restrict_background_blacklisted" msgid="3995443391711013068">"Data na pozadí jsou vypnuta"</string>
    <string name="data_saver_on" msgid="6774217590237934709">"Zapnuto"</string>
    <string name="data_saver_off" msgid="6892309031162738794">"Vypnuto"</string>
    <string name="data_saver_switch_title" msgid="836312690356005669">"Použít spořič dat"</string>
    <string name="unrestricted_app_title" msgid="4465437191723332066">"Neomezené využití dat"</string>
    <string name="unrestricted_app_summary" msgid="6458008993501723912">"Povolit neomezený přístup k datům, když je zapnutý Spořič dat"</string>
    <string name="home_app" msgid="4066188520886810030">"Výchozí aplikace"</string>
    <string name="no_default_home" msgid="7184117487704520238">"Žádná výchozí aplikace"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="3832020101401318248">"Bezpečné spuštění"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="7873036097628404476">"Při spuštění zařízení požadovat gesto. Vypnuté zařízení nemůže přijímat hovory, zprávy, oznámení ani budíky."</string>
    <string name="lockpattern_settings_require_pin_before_startup_summary" msgid="6022831284097476933">"Při spuštění zařízení požadovat PIN. Vypnuté zařízení nemůže přijímat hovory, zprávy, oznámení ani budíky."</string>
    <string name="lockpattern_settings_require_password_before_startup_summary" msgid="6818285221244966231">"Při spuštění zařízení požadovat heslo. Vypnuté zařízení nemůže přijímat hovory, zprávy, oznámení ani budíky."</string>
    <string name="suggestion_additional_fingerprints" msgid="2214281455363797037">"Přidejte další otisk"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="5471253233176471245">"Odemknout jiným prstem"</string>
    <string name="battery_saver_on_summary" msgid="7722791295871319534">"Zapnuto"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="3953785517002197881">"Zapne se při <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="784360321235698247">"Vypnuto"</string>
    <string name="battery_saver_button_turn_on" msgid="3699954061337848832">"Zapnout"</string>
    <string name="battery_saver_button_turn_off" msgid="5916996792004611890">"Vypnout"</string>
    <string name="not_battery_optimizing" msgid="5362861851864837617">"Nepoužívá optimalizaci baterie"</string>
    <string name="lockscreen_remote_input" msgid="969871538778211843">"Pokud je zařízení zamknuté, zakázat psaní odpovědí a jiných textů do oznámení"</string>
    <string name="default_spell_checker" msgid="8506899870026026660">"Výchozí kontrola pravopisu"</string>
    <string name="choose_spell_checker" msgid="6596539862291699367">"Výběr kontroly pravopisu"</string>
    <string name="spell_checker_master_switch_title" msgid="8763132750954344372">"Použít kontrolu pravopisu"</string>
    <string name="spell_checker_not_selected" msgid="8871083796179200696">"Nevybráno"</string>
    <string name="notification_log_no_title" msgid="5678029849672024215">"(žádný)"</string>
    <string name="notification_log_details_delimiter" msgid="3116559361552416747">": "</string>
    <string name="notification_log_details_package" msgid="2596495677039100284">"pkg"</string>
    <string name="notification_log_details_key" msgid="2995791937075862968">"klíč"</string>
    <string name="notification_log_details_group" msgid="2430467015200368698">"skupina"</string>
    <string name="notification_log_details_group_summary" msgid="7945543958255585829">"(souhrn)"</string>
    <string name="notification_log_details_visibility" msgid="2552873780715930971">"viditelnost"</string>
    <string name="notification_log_details_public_version" msgid="4247242364605495240">"publicVersion"</string>
    <string name="notification_log_details_priority" msgid="8371354971235991398">"priorita"</string>
    <string name="notification_log_details_importance" msgid="2153168790791683139">"důležitost"</string>
    <string name="notification_log_details_explanation" msgid="1914295130775393551">"vysvětlení"</string>
    <string name="notification_log_details_badge" msgid="3258183328267662285">"může zobrazovat odznak"</string>
    <string name="notification_log_details_content_intent" msgid="1113554570409128083">"objekt Intent"</string>
    <string name="notification_log_details_delete_intent" msgid="905118520685297007">"smazání objektu Intent"</string>
    <string name="notification_log_details_full_screen_intent" msgid="7118560817013522978">"objekt Intent pro celou obrazovku"</string>
    <string name="notification_log_details_actions" msgid="242523930165118066">"akce"</string>
    <string name="notification_log_details_title" msgid="7177091647508863295">"nadpis"</string>
    <string name="notification_log_details_remoteinput" msgid="8328591329858827409">"vzdálené vstupy"</string>
    <string name="notification_log_details_content_view" msgid="6638731378278561786">"vlastní zobrazení"</string>
    <string name="notification_log_details_extras" msgid="4188418723779942047">"extra"</string>
    <string name="notification_log_details_icon" msgid="8939114059726188218">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="243148037601903212">"velikost zásilky"</string>
    <string name="notification_log_details_ashmem" msgid="7241814108477320636">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="6622944771989529320">"bylo zobrazeno oznámení"</string>
    <string name="notification_log_details_sound" msgid="5506232879598808099">"zvuk"</string>
    <string name="notification_log_details_vibrate" msgid="6890065466625335940">"vibrace"</string>
    <string name="notification_log_details_vibrate_pattern" msgid="6076984056201975221">"vzor"</string>
    <string name="notification_log_details_default" msgid="2345249399796730861">"výchozí"</string>
    <string name="notification_log_details_none" msgid="184131801230614059">"žádné"</string>
    <string name="notification_log_details_ranking_null" msgid="244660392058720919">"Objekt hodnocení chybí."</string>
    <string name="notification_log_details_ranking_none" msgid="599607025882587844">"Objekt hodnocení tento klíč neobsahuje."</string>
    <string name="theme_customization_category" msgid="1049181544004163283">"Nastavování motivů"</string>
    <string name="theme_customization_accent_color_title" msgid="2946868019715911717">"Barva zvýraznění"</string>
    <string name="theme_customization_font_title" msgid="1634160034866477544">"Písmo pro nadpis/tělo"</string>
    <string name="theme_customization_icon_shape_title" msgid="9168569756271940841">"Tvar ikony"</string>
    <string name="theme_customization_device_default" msgid="5058147707906551368">"Výchozí nastavení zařízení"</string>
    <string name="display_cutout_emulation" msgid="7466869822418376317">"Výřez displeje"</string>
    <string name="display_cutout_emulation_keywords" msgid="4495418317471622562">"výřez displeje"</string>
    <string name="overlay_option_device_default" msgid="294510212512203638">"Výchozí nastavení zařízení"</string>
    <string name="overlay_toast_failed_to_apply" msgid="3506731619973103346">"Překrytí se nepodařilo použít"</string>
    <string name="special_access" msgid="3458780842491881155">"Přístup ke spec. aplikacím"</string>
    <plurals name="special_access_summary" formatted="false" msgid="260765309935675867">
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikace mohou využívat neomezená data</item>
      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> aplikace může využívat neomezená data</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikací může využívat neomezená data</item>
      <item quantity="one">1 aplikace může využívat neomezená data</item>
    </plurals>
    <string name="special_access_more" msgid="6927066457969301921">"Zobrazit více"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="1487005506049137659">"Opravdu chcete vymazat údaje o uživateli a aktivovat šifrování souboru?"</string>
    <string name="button_confirm_convert_fbe" msgid="7101855374850373091">"Vymazat a aktivovat"</string>
    <string name="reset_shortcut_manager_throttling" msgid="6495066467198668994">"Resetovat limity četnosti služby ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="1826770872063707900">"Limity četnosti služby ShortcutManager byly resetovány"</string>
    <string name="notification_suggestion_title" msgid="387052719462473500">"Nastavte informace na obrazovce uzamčení"</string>
    <string name="notification_suggestion_summary" msgid="8521159741445416875">"Zobrazit nebo skrýt obsah oznámení"</string>
    <string name="page_tab_title_summary" msgid="4070309266374993258">"Vše"</string>
    <string name="page_tab_title_support" msgid="4407600495101788249">"Tipy a podpora"</string>
    <string name="developer_smallest_width" msgid="7516950434587313360">"Minimální šířka"</string>
    <string name="premium_sms_none" msgid="8268105565738040566">"Žádné nainstalované aplikace o přístup k prémiovým SMS nepožádaly"</string>
    <string name="premium_sms_warning" msgid="9086859595338944882">"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="4660047004791638305">"Přístup k prémiovým SMS"</string>
    <string name="bluetooth_disabled" msgid="6244000672828617410">"Vypnuto"</string>
    <string name="bluetooth_connected_summary" msgid="7672528674593152862">"Připojeno k zařízení <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="9173661896296663932">"Připojeno k několika zařízením"</string>
    <string name="demo_mode" msgid="2798762752209330277">"Ukázkový režim uživatelského rozhraní systému"</string>
    <!-- no translation found for dark_ui_mode (3888371857083890543) -->
    <skip />
    <string name="dark_ui_settings_dark_summary" msgid="8205234847639399279">"Na tmavý motiv se přepnou i podporované aplikace"</string>
    <!-- no translation found for dark_ui_settings_dialog_acknowledge (8683868642329596059) -->
    <skip />
    <string name="quick_settings_developer_tiles" msgid="5947788063262762448">"Dlaždice rychlého nastavení pro vývojáře"</string>
    <string name="winscope_trace_quick_settings_title" msgid="1294290008255732032">"Trasování Winscope"</string>
    <string name="sensors_off_quick_settings_title" msgid="1487323753632515801">"Senzory jsou vypnuty"</string>
    <string name="managed_profile_settings_title" msgid="2729481936758125054">"Nastavení pracovního profilu"</string>
    <string name="managed_profile_contact_search_title" msgid="6034734926815544221">"Vyhledávání kontaktů"</string>
    <string name="managed_profile_contact_search_summary" msgid="5431253552272970512">"Povolit vyhledávání kontaktů organizací za účelem identifikace volajících a kontaktů"</string>
    <string name="cross_profile_calendar_title" msgid="4414835261437899531">"Kalendář z více profilů"</string>
    <string name="cross_profile_calendar_summary" msgid="8139424817135929870">"Zobrazovat v osobním kalendáři pracovní události"</string>
    <string name="cross_profile_calendar_restricted_summary" msgid="295371538704418613">"Vaše organizace neumožňuje zobrazení pracovního kalendáře pomocí osobních aplikací"</string>
    <plurals name="hours" formatted="false" msgid="7020844602875333472">
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> hodiny</item>
      <item quantity="many"><xliff:g id="NUMBER">%s</xliff:g> hodiny</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> hodin</item>
      <item quantity="one">1 hodina</item>
    </plurals>
    <plurals name="minutes" formatted="false" msgid="4666832442068789413">
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> minuty</item>
      <item quantity="many"><xliff:g id="NUMBER">%s</xliff:g> minuty</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> minut</item>
      <item quantity="one">1 minuta</item>
    </plurals>
    <plurals name="seconds" formatted="false" msgid="3876307354560025025">
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> sekundy</item>
      <item quantity="many"><xliff:g id="NUMBER">%s</xliff:g> sekundy</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> sekund</item>
      <item quantity="one">1 sekunda</item>
    </plurals>
    <string name="automatic_storage_manager_settings" msgid="7819434542155181607">"Spravovat úložiště"</string>
    <string name="automatic_storage_manager_text" msgid="4562950476680600604">"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="2017913896160914647">"Odstranit fotky a videa"</string>
    <string name="automatic_storage_manager_preference_title" msgid="5753702798151073383">"Správce úložiště"</string>
    <string name="automatic_storage_manager_master_switch_title" msgid="6792996736190821417">"Používat správce úložiště"</string>
    <string name="deletion_helper_automatic_title" msgid="6605660435498272520">"Automaticky"</string>
    <string name="deletion_helper_manual_title" msgid="7947432164411214029">"Ruční"</string>
    <string name="deletion_helper_preference_title" msgid="5271510052022285884">"Uvolnit místo"</string>
    <string name="gesture_preference_title" msgid="5280023307132819052">"Gesta"</string>
    <string name="gesture_preference_summary" product="default" msgid="8627850388011956901">"Rychlá gesta k ovládání telefonu"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4717535378272065510">"Rychlá gesta k ovládání tabletu"</string>
    <string name="gesture_preference_summary" product="device" msgid="4205941452664950852">"Rychlá gesta k ovládání zařízení"</string>
    <string name="double_tap_power_for_camera_title" msgid="64716226816032800">"Spuštění fotoaparátu"</string>
    <string name="double_tap_power_for_camera_summary" msgid="242037150983277829">"Chcete-li rychle spustit fotoaparát, dvakrát stiskněte vypínač. Funguje to na všech obrazovkách."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="6500405261202883589">"Otevírejte fotoaparát rychle"</string>
    <string name="double_twist_for_camera_mode_title" msgid="4877834147983530479">"Přepnutí fotoaparátu"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="122977081337563340"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="4689410222517954869">"Foťte selfie rychleji"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="5367798220225997418">"Mezi aplikacemi přepnete přejetím prstem nahoru po tlačítku plochy. Opětovným přejetím nahoru zobrazíte všechny aplikace. Funguje to na všech obrazovkách. V pravé dolní části obrazovky již nebude k dispozici tlačítko Přehled."</string>
    <string name="swipe_up_to_switch_apps_suggestion_title" msgid="1465200107913259595">"Vyzkoušejte nové tlačítko plochy"</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="4825314186907812743">"Zapněte nové gesto k přepínání aplikací"</string>
    <string name="ambient_display_title" product="default" msgid="5144814600610448504">"Kontrola telefonu dvojitým klepnutím"</string>
    <string name="ambient_display_title" product="tablet" msgid="8688795028609563837">"Kontrola tabletu dvojitým klepnutím"</string>
    <string name="ambient_display_title" product="device" msgid="3423781975742145894">"Kontrola zařízení dvojitým klepnutím"</string>
    <string name="ambient_display_summary" msgid="8534654210539169707">"Chcete-li zobrazit čas, oznámení a další informace, dvakrát klepněte na obrazovku."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="818688002837687268">"Kontrola telefonu zvednutím"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="4455864282995698097">"Kontrola tabletu zvednutím"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="5380534405773531175">"Kontrola zařízení zvednutím"</string>
    <string name="ambient_display_wake_screen_title" msgid="4091523525326925790">"Zobrazení po probuzení"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="3436302177038243869">"Chcete-li zobrazit čas, oznámení a další informace, zvedněte telefon."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="4938504160398665156">"Chcete-li zobrazit čas, oznámení a další informace, zvedněte tablet."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="4264958533375250254">"Chcete-li zobrazit čas, oznámení a další informace, zvedněte zařízení."</string>
    <string name="ambient_display_tap_screen_title" product="default" msgid="5458679563086979424">"Kontrola telefonu klepnutím"</string>
    <string name="ambient_display_tap_screen_title" product="tablet" msgid="9108878716863882877">"Kontrola tabletu klepnutím"</string>
    <string name="ambient_display_tap_screen_title" product="device" msgid="7071150656699666085">"Kontrola zařízení klepnutím"</string>
    <string name="ambient_display_tap_screen_summary" msgid="8862155601920379979">"Chcete-li zobrazit čas, oznámení a další informace, klepněte na obrazovku."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="5816346492253270243">"Otisk prstu pro oznámení"</string>
    <string name="fingerprint_gesture_screen_title" msgid="8562169633234041196">"Přejeďte po otisku"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="1770661868393713922">"Chcete-li zkontrolovat oznámení, přejeďte prstem dolů po snímači otisků prstů na zadní straně telefonu."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet" msgid="902719947767712895">"Chcete-li zkontrolovat oznámení, přejeďte prstem dolů po snímači otisků prstů na zadní straně tabletu."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="device" msgid="5372926094116306647">"Chcete-li zkontrolovat oznámení, přejeďte prstem dolů po snímači otisků prstů na zadní straně zařízení."</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="1677291167470357802">"Zobrazujte oznámení rychle"</string>
    <string name="gesture_setting_on" msgid="3455094265233870280">"Zapnuto"</string>
    <string name="gesture_setting_off" msgid="5230169535435881894">"Vypnuto"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="4265541229765635629">"Zavaděč je již odemknut"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="3361344735430813695">"Nejprve se připojte k internetu"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="2479038689567925511">"Připojte se k internetu nebo kontaktujte operátora"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="4149387448213399630">"Není k dispozici v zařízeních uzamčených operátorem"</string>
    <string name="oem_lock_info_message" msgid="9218313722236417510">"Chcete-li aktivovat ochranu, restartujte zařízení."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="7517560170441007788">"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="4051513950976670853">"Okamžité aplikace"</string>
    <string name="web_action_enable_summary" msgid="3108127559723396382">"Otevírejte odkazy v aplikacích, i když je nemáte nainstalované"</string>
    <string name="web_action_section_title" msgid="7364647086538399136">"Okamžité aplikace"</string>
    <string name="instant_apps_settings" msgid="8827777916518348213">"Předvolby okamžitých aplikací"</string>
    <string name="domain_url_section_title" msgid="7046835219056428883">"Nainstalované aplikace"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="6353100011690933254">"Úložiště je teď spravováno správcem úložiště."</string>
    <string name="account_for_section_header" msgid="5356566418548737121">"Účty uživatele <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="configure_section_header" msgid="7391183586410814450">"Konfigurace"</string>
    <string name="auto_sync_account_title" msgid="898796354710116383">"Automaticky synchronizovat data"</string>
    <string name="auto_sync_personal_account_title" msgid="8496263182646100610">"Automaticky synchronizovat osobní data"</string>
    <string name="auto_sync_work_account_title" msgid="4489172450037434152">"Automaticky synchronizovat pracovní data"</string>
    <string name="auto_sync_account_summary" msgid="692499211629185107">"Nechat aplikace automaticky aktualizovat data"</string>
    <string name="account_sync_title" msgid="7214747784136106491">"Synchronizace účtů"</string>
    <string name="account_sync_summary_some_on" msgid="3375930757891381175">"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="570431636622254156">"Synchronizace je zapnuta u všech položek"</string>
    <string name="account_sync_summary_all_off" msgid="8782409931761182734">"Synchronizace je vypnuta u všech položek"</string>
    <string name="enterprise_privacy_settings" msgid="1177106810374146496">"Informace o spravovaném zařízení"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5853292305730761128">"Změny a nastavení spravuje organizace"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="4266234968317996188">"Změny a nastavení spravuje organizace <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="7402406406883832509">"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="7313392680107938517">"Typy informací, které vidí vaše organizace"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="9079283547182933771">"Změny, které provedl administrátor vaší organizace"</string>
    <string name="enterprise_privacy_device_access_category" msgid="5423434164248819058">"Váš přístup k tomuto zařízení"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="2773968662865848413">"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="2313698828178764590">"Seznam aplikací ve vašem zařízení"</string>
    <string name="enterprise_privacy_usage_stats" msgid="4398411405572759370">"Doba používání jednotlivých aplikací a množství jimi využitých dat"</string>
    <string name="enterprise_privacy_network_logs" msgid="161722817268849590">"Nejnovější protokol síťového provozu"</string>
    <string name="enterprise_privacy_bug_reports" msgid="843225086779037863">"Nejnovější zpráva o chybě"</string>
    <string name="enterprise_privacy_security_logs" msgid="5377362481617301074">"Nejnovější protokol zabezpečení"</string>
    <string name="enterprise_privacy_none" msgid="7706621148858381189">"Žádné"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="6353757812144878828">"Nainstalované aplikace"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7433213592572082606">"Počet aplikací je odhad. Nemusí zahrnovat aplikace nainstalované mimo Obchod Play."</string>
    <plurals name="enterprise_privacy_number_packages_lower_bound" formatted="false" msgid="3005116533873542976">
      <item quantity="few">Minimálně <xliff:g id="COUNT_1">%d</xliff:g> aplikace</item>
      <item quantity="many">Minimálně <xliff:g id="COUNT_1">%d</xliff:g> aplikace</item>
      <item quantity="other">Minimálně <xliff:g id="COUNT_1">%d</xliff:g> aplikací</item>
      <item quantity="one">Minimálně <xliff:g id="COUNT_0">%d</xliff:g> aplikace</item>
    </plurals>
    <string name="enterprise_privacy_location_access" msgid="4158197200885270634">"Oprávnění přístupu k poloze"</string>
    <string name="enterprise_privacy_microphone_access" msgid="5717375623568864441">"Oprávnění přístupu k mikrofonu"</string>
    <string name="enterprise_privacy_camera_access" msgid="4858146118537519375">"Oprávnění přístupu k fotoaparátu"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="3288495615791128724">"Výchozí aplikace"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="2765037387436064893">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> aplikace</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> aplikace</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aplikací</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> aplikace</item>
    </plurals>
    <string name="enterprise_privacy_input_method" msgid="6531350246850814920">"Výchozí klávesnice"</string>
    <string name="enterprise_privacy_input_method_name" msgid="4941106433683067953">"Nastaveno na <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="4409098287763221215">"Trvalá síť VPN je zapnutá"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="9217774730260037434">"Trvalá síť VPN je zapnutá v osobním profilu"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="7244472958208315814">"Trvalá síť VPN je zapnutá v pracovním profilu"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="7936664553416257333">"Globální proxy server protokolu HTTP je nastaven"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="2019652712782510262">"Důvěryhodné identifikační údaje"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="2279084820904076599">"Důvěryhodné identifikační údaje ve vašem osobním profilu"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="6187377647815301809">"Důvěryhodné identifikační údaje ve vašem pracovním profilu"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="526375234629534165">
      <item quantity="few">Minimálně <xliff:g id="COUNT_1">%d</xliff:g> certifikáty CA</item>
      <item quantity="many">Minimálně <xliff:g id="COUNT_1">%d</xliff:g> certifikátu CA</item>
      <item quantity="other">Minimálně <xliff:g id="COUNT_1">%d</xliff:g> certifikátů CA</item>
      <item quantity="one">Minimálně <xliff:g id="COUNT_0">%d</xliff:g> certifikát CA</item>
    </plurals>
    <string name="enterprise_privacy_lock_device" msgid="8791656477097208540">"Administrátor může zařízení uzamknout a resetovat heslo"</string>
    <string name="enterprise_privacy_wipe_device" msgid="2821960015797241790">"Administrátor může smazat všechna data v zařízení"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="1001255609345002878">"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="4040565826652951057">"Nezdařené pokusy o zadání hesla před smazáním dat z pracovního profilu"</string>
    <plurals name="enterprise_privacy_number_failed_password_wipe" formatted="false" msgid="5279099270351036696">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> pokusy</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g> pokusu</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> pokusů</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> pokus</item>
    </plurals>
    <string name="do_disclosure_generic" msgid="8653670456990823307">"Toto zařízení spravuje vaše organizace."</string>
    <string name="do_disclosure_with_name" msgid="1141081465968481380">"Toto zařízení je spravováno organizací <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="3558079393757238670">" "</string>
    <string name="learn_more" msgid="2623878455042103404">"Další informace"</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="1134677050353971363">
      <item quantity="few">Aplikace k focení a natáčení</item>
      <item quantity="many">Aplikace k focení a natáčení</item>
      <item quantity="other">Aplikace k focení a natáčení</item>
      <item quantity="one">Aplikace k focení a natáčení</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="3545972964391065220">"Kalendářová aplikace"</string>
    <string name="default_contacts_app_title" msgid="3497370557378660098">"Aplikace pro kontakty"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="42826975161049245">
      <item quantity="few">Aplikace pro práci s e‑maily</item>
      <item quantity="many">Aplikace pro práci s e‑maily</item>
      <item quantity="other">Aplikace pro práci s e‑maily</item>
      <item quantity="one">Aplikace pro práci s e‑maily</item>
    </plurals>
    <string name="default_map_app_title" msgid="7560143381633608567">"Mapová aplikace"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="6714041230953195024">
      <item quantity="few">Aplikace k telefonování</item>
      <item quantity="many">Aplikace k telefonování</item>
      <item quantity="other">Aplikace k telefonování</item>
      <item quantity="one">Aplikace k telefonování</item>
    </plurals>
    <string name="app_names_concatenation_template_2" msgid="4309216198909946380">"<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="8949045544491604376">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_photos_videos" msgid="319854636702241898">"Fotky a videa"</string>
    <string name="storage_music_audio" msgid="789779084825206838">"Hudba a zvuk"</string>
    <string name="storage_games" msgid="7703159201697117621">"Hry"</string>
    <string name="storage_other_apps" msgid="5524321740031718083">"Další aplikace"</string>
    <string name="storage_files" msgid="8581083146777364063">"Soubory"</string>
    <string name="storage_size_large_alternate" msgid="3395208658399637645">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">^2</xliff:g>"</font></small>""</string>
    <string name="storage_volume_total" msgid="3499221850532701342">"Využito z <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_percent_full" msgid="6095012055875077036">"využito"</string>
    <string name="clear_instant_app_data" msgid="2004222610585890909">"Vymazat aplikaci"</string>
    <string name="clear_instant_app_confirmation" msgid="7451671214898856857">"Chcete tuto okamžitou aplikaci odstranit?"</string>
    <string name="launch_instant_app" msgid="391581144859010499">"Otevřít"</string>
    <string name="game_storage_settings" msgid="3410689937046696557">"Hry"</string>
    <string name="audio_files_title" msgid="4777048870657911307">"Zvukové soubory"</string>
    <string name="app_info_storage_title" msgid="5554719444625611987">"Využitý prostor"</string>
    <string name="webview_uninstalled_for_user" msgid="1819903169194420983">"(pro uživatele <xliff:g id="USER">%s</xliff:g> odinstalováno)"</string>
    <string name="webview_disabled_for_user" msgid="1216426047631256825">"(pro uživatele <xliff:g id="USER">%s</xliff:g> nedostupné)"</string>
    <string name="autofill_app" msgid="7338387238377914374">"Služba automatického vyplňování"</string>
    <string name="autofill_keywords" msgid="7485591824120812710">"automatické vyplňování, vyplňování"</string>
    <string name="autofill_confirmation_message" msgid="2784869528908005194">"&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 na základě obsahu obrazovky, co lze automaticky vyplnit."</string>
    <string name="debug_autofill_category" msgid="8050326960545979035">"Automatické vyplňování"</string>
    <string name="autofill_logging_level_title" msgid="899483289251346778">"Úroveň protokolování"</string>
    <string name="autofill_max_partitions" msgid="7590272120101271461">"Maximální počet žádosti na relaci"</string>
    <string name="autofill_max_visible_datasets" msgid="4531033613378881109">"Max. viditelných datových sad"</string>
    <string name="autofill_reset_developer_options" msgid="5819016237049525099">"Resetovat na výchozí hodnoty"</string>
    <string name="autofill_reset_developer_options_complete" msgid="7548288932341619412">"Možnosti automatického vyplňování pro vývojáře byly resetovány"</string>
    <string name="device_theme" msgid="4571803018917608588">"Motiv zařízení"</string>
    <string name="default_theme" msgid="7085644992078579076">"Výchozí"</string>
    <string name="show_operator_name_title" msgid="805135053530442951">"Název sítě"</string>
    <string name="show_operator_name_summary" msgid="5962567590205757550">"Zobrazovat název sítě na stavovém řádku"</string>
    <string name="storage_manager_indicator" msgid="1516810749625915020">"Správce úložiště: <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="7488057587180724388">"Vypnuto"</string>
    <string name="storage_manager_indicator_on" msgid="8625551710194584733">"Zapnuto"</string>
    <string name="install_type_instant" msgid="3174425974536078647">"Okamžitá aplikace"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="5605210730828410482">"Chcete vypnout správce úložiště?"</string>
    <string name="storage_movies_tv" msgid="5498394447562086890">"Aplikace pro filmy a TV"</string>
    <string name="carrier_provisioning" msgid="4398683675591893169">"Informace o zprovoznění služby u operátora"</string>
    <string name="trigger_carrier_provisioning" msgid="3434865918009286187">"Spustit zprovoznění služby u operátora"</string>
    <string name="zen_suggestion_title" msgid="798067603460192693">"Aktualizujte režim Nerušit"</string>
    <string name="zen_suggestion_summary" msgid="5928686804697233014">"Pokud nechcete být rušeni, oznámení pozastavte"</string>
    <string name="disabled_low_ram_device" msgid="3751578499721173344">"Funkce v tomto zařízení není k dispozici"</string>
    <string name="disabled_feature" msgid="2102058661071271076">"Tato funkce není k dispozici"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="6377125503096655882">"Bude zpomalovat telefon"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1294470289520660584">"Vynutit úplné měření GNSS"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="496344699046454200">"Sledovat všechny konstelace a frekvence GNSS bez cyklického vypínání a zapínání"</string>
    <string name="allow_background_activity_starts" msgid="4121456477541603005">"Povolit zahájení aktivity na pozadí"</string>
    <string name="allow_background_activity_starts_summary" msgid="6837591829176921245">"Povolí veškerá zahájení aktivity na pozadí"</string>
    <string name="show_first_crash_dialog" msgid="8889957119867262599">"Vždy zobrazit dialog o pádu"</string>
    <string name="show_first_crash_dialog_summary" msgid="703224456285060428">"Zobrazit dialog při každém pádu aplikace"</string>
    <string name="angle_enabled_app" msgid="1841862539745838255">"Vyberte aplikaci podporující ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="864740024581634768">"Není nastavena žádná aplikace podporující ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="226015765615525056">"Aplikace podporující ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="game_driver_dashboard_title" msgid="8804074441354504919">"Předvolby herního ovladače"</string>
    <string name="game_driver_dashboard_summary" msgid="2392113100578771289">"Upravit nastavení herního ovladače"</string>
    <string name="game_driver_footer_text" msgid="3202576403048267763">"Když je zapnutý herní ovladač, můžete pro aplikace nainstalované v zařízení používat aktualizovaný ovladač grafiky."</string>
    <string name="game_driver_all_apps_preference_title" msgid="6067527642706295180">"Zapnout pro všechny aplikace"</string>
    <string name="game_driver_app_preference_title" msgid="5072626013346650374">"Vyberte ovladač grafiky"</string>
    <string name="game_driver_app_preference_default" msgid="7686384740483216333">"Výchozí"</string>
    <string name="game_driver_app_preference_game_driver" msgid="6426312331295324606">"Herní ovladač"</string>
    <string name="game_driver_app_preference_system" msgid="8272672982113332753">"Systémový ovladač grafiky"</string>
    <!-- no translation found for game_driver_app_preference_values:0 (4271044622117073985) -->
    <!-- no translation found for game_driver_app_preference_values:1 (6628516810440406199) -->
    <!-- no translation found for game_driver_app_preference_values:2 (1760397725970916076) -->
    <string name="unsupported_setting_summary" product="default" msgid="11246953620654225">"Nastavení v tomto telefonu není podporováno"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="6328431665635673717">"Nastavení v tomto tabletu není podporováno"</string>
    <string name="unsupported_setting_summary" product="device" msgid="2348970994972110886">"Nastavení v tomto zařízení není podporováno"</string>
    <string name="disabled_for_user_setting_summary" msgid="3388525317680711262">"Aktuální uživatel toto nastavení nemůže změnit"</string>
    <string name="disabled_dependent_setting_summary" msgid="8291322239940946902">"Závisí na jiném nastavení"</string>
    <string name="unknown_unavailability_setting_summary" msgid="4589584678033059435">"Nastavení není k dispozici"</string>
    <string name="my_device_info_account_preference_title" msgid="342933638925781861">"Účet"</string>
    <string name="my_device_info_device_name_preference_title" msgid="7104085224684165324">"Název zařízení"</string>
    <string name="change_wifi_state_title" msgid="3261945855372885427">"Ovládání sítí Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="7942268646980694224">"Povolit aplikaci ovládat Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8434262633905502679">"Povolte této aplikaci 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="media_output_title" msgid="115223550977351699">"Přehrávat média v"</string>
    <string name="media_output_default_summary" msgid="8115153381240348279">"Toto zařízení"</string>
    <string name="media_output_summary" product="default" msgid="6839458453831567167">"Telefon"</string>
    <string name="media_output_summary" product="tablet" msgid="7217221078578554515">"Tablet"</string>
    <string name="media_output_summary" product="device" msgid="5677420090811068649">"Zařízení"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="3533731701018680693">"Při volání nedostupné"</string>
    <string name="media_output_summary_unavailable" msgid="7970304720507697019">"Nedostupné"</string>
    <string name="take_call_on_title" msgid="6066362463436122655">"Přijmout hovor v zařízení"</string>
    <string name="cannot_change_apn_toast" msgid="4652498125702594916">"Tento APN nelze změnit."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="752439050748267917">"Zvyšte životnost baterie tabletu"</string>
    <string name="battery_suggestion_title" product="device" msgid="1507272328369733005">"Zvyšte životnost baterie zařízení"</string>
    <string name="battery_suggestion_title" product="default" msgid="4038053023336285165">"Zvyšte životnost baterie telefonu"</string>
    <string name="battery_suggestion_summary" msgid="4585677159811722359"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="7840226017975251549">"Blokování vyzvánění"</string>
    <string name="gesture_prevent_ringing_title" msgid="5961391929839748111">"Stisknutí vypínače a zvýšení hlasitosti znamená:"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="5724512060316688779">"Zkratka k vypnutí vyzvánění"</string>
    <string name="prevent_ringing_option_vibrate" msgid="7286821846542822661">"Vibrovat"</string>
    <string name="prevent_ringing_option_mute" msgid="7551545579059879853">"Ztlumit"</string>
    <string name="prevent_ringing_option_none" msgid="4656046650769569175">"Nic nedělat"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="1157524435626890116">"Zapnuto (vibrace)"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="4472465110708640980">"Zapnuto (ztlumeno)"</string>
    <string name="prevent_ringing_option_none_summary" msgid="5013718946609276137">"Vypnuto"</string>
    <string name="pref_title_network_details" msgid="7186418845727358964">"Podrobnosti sítě"</string>
    <string name="about_phone_device_name_warning" msgid="8885670415541365348">"Název vašeho zařízení je viditelný pro aplikace v telefonu. Mohou ho vidět také ostatní uživatelé, když se připojíte k zařízení Bluetooth nebo hotspotu Wi-Fi."</string>
    <string name="devices_title" msgid="7701726109334110391">"Zařízení"</string>
    <string name="homepage_all_settings" msgid="1245540304900512919">"Všechna nastavení"</string>
    <string name="homepage_personal_settings" msgid="1570415428680432319">"Návrhy"</string>
    <string name="choose_network_title" msgid="5702586742615861037">"Vybrat síť"</string>
    <string name="network_disconnected" msgid="2933191767567503504">"Odpojeno"</string>
    <string name="network_connected" msgid="4943925032253989621">"Připojeno"</string>
    <string name="network_connecting" msgid="76404590784733557">"Připojování…"</string>
    <string name="network_could_not_connect" msgid="1113813392274155369">"Nelze se připojit"</string>
    <string name="empty_networks_list" msgid="2578752112731781190">"Žádná síť nebyla nalezena."</string>
    <string name="network_query_error" msgid="7487714485362598410">"Nebyla nalezena žádná síť. Zkuste to znovu."</string>
    <string name="forbidden_network" msgid="4626592887509826545">"(zakázáno)"</string>
    <string name="no_sim_card" msgid="1360669528113557381">"Není vložena SIM karta"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="3956515670308744433">"Preferovaný režim sítě: preferováno WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="5225727680228194864">"Preferovaný režim sítě: pouze GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="8956197584659205699">"Preferovaný režim sítě: pouze WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="4290654515569144276">"Preferovaný režim sítě: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="854981096234906594">"Preferovaný režim sítě: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="2578065433446506616">"Preferovaný režim sítě: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6604102246309629962">"Preferovaný režim sítě: pouze CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="7558385602277592784">"Preferovaný režim sítě: pouze EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="1742638677806401815">"Preferovaný režim sítě: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="8528755811985330696">"Preferovaný režim sítě: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="6632007438739933645">"Preferovaný režim sítě: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="5464960267483576515">"Preferovaný režim sítě: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_global_summary" msgid="8552400100470153638">"Preferovaný režim sítě: Globální"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="8037915274486919940">"Preferovaný režim sítě: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="104110625441127919">"Preferovaný režim sítě: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2561159741461407053">"Preferovaný režim sítě: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="1111689194136766011">"Preferovaný režim sítě: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="4272515966019344433">"Preferovaný režim sítě: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3138210224248737600">"Preferovaný režim sítě: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="7575595856957063853">"Preferovaný režim sítě: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="1512046749970721629">"Preferovaný režim sítě: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="1038314909945393905">"Preferovaný režim sítě: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="3277980364222159279">"Preferovaný režim sítě: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1572937828071126891">"Preferovaný režim sítě: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8393145171649288912">"Preferovaný režim sítě: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="5544016990994809932">"Preferovaný režim sítě: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_lte" msgid="1287709529829131860">"LTE (doporučeno)"</string>
    <string name="network_4G" msgid="8611758013994499559">"4G (doporučeno)"</string>
    <string name="network_global" msgid="959947774831178632">"Globální"</string>
    <string name="label_available" msgid="1731547832803057893">"Dostupné sítě"</string>
    <string name="load_networks_progress" msgid="7709402068413190831">"Vyhledávání…"</string>
    <string name="register_on_network" msgid="766516026652295941">"Probíhá registrace v síti <xliff:g id="NETWORK">%s</xliff:g>…"</string>
    <string name="not_allowed" msgid="1667079919821581706">"Vaše SIM karta nepovoluje připojení k této síti."</string>
    <string name="connect_later" msgid="978991102125216741">"K této síti se momentálně nelze přihlásit. Zkuste to znovu později."</string>
    <string name="registration_done" msgid="4573820010512184521">"Přihlášení k síti bylo úspěšné."</string>
    <string name="select_automatically" msgid="7318032984017853975">"Vybírat síť automaticky"</string>
    <string name="carrier_settings_title" msgid="3503012527671299886">"Nastavení operátora"</string>
    <string name="cdma_lte_data_service" msgid="8507044148856536098">"Nastavit datovou službu"</string>
    <string name="mobile_data_settings_title" msgid="7674604042461065482">"Mobilní data"</string>
    <string name="mobile_data_settings_summary" msgid="2708261377199805404">"Přistupovat k datům přes mobilní síť"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="2914985502279794000">"Telefon se v dosahu automaticky přepne na tohoto operátora"</string>
    <string name="calls_preference" msgid="4628557570999372758">"Předvolby hovorů"</string>
    <string name="sms_preference" msgid="3479810211828513772">"Předvolby SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="2127802836576375306">"Pokaždé se zeptat"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9148476748420654283">"Přidat síť"</string>
    <plurals name="mobile_network_summary_count" formatted="false" msgid="4505694491027023039">
      <item quantity="few"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM karty</item>
      <item quantity="many"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM karty</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM karet</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> SIM karta</item>
    </plurals>
    <string name="default_for_calls" msgid="6732520879241581841">"Výchozí pro hovory"</string>
    <string name="default_for_sms" msgid="294276190503132313">"Výchozí pro SMS"</string>
    <string name="default_for_calls_and_sms" msgid="3862322027700754792">"Výchozí pro hovory a SMS"</string>
    <string name="default_for_mobile_data" msgid="955987144209828344">"Výchozí pro mobilní data"</string>
    <string name="mobile_data_active" msgid="5108294051762397700">"Mobilní data jsou aktivní"</string>
    <string name="mobile_data_off" msgid="5831854766113105657">"Mobilní data jsou vypnuta"</string>
    <string name="subscription_available" msgid="6502502298446954785">"Dostupné"</string>
    <string name="mobile_network_in_range" msgid="8212440637838603215">"V rozsahu"</string>
    <string name="mobile_network_not_in_range" msgid="5287596455212313284">"Mimo dosah"</string>
    <string name="mobile_network_list_add_more" msgid="4000806369124701679">"Přidat další"</string>
    <string name="mobile_network_active_sim" msgid="2375956837678169169">"Aktivní / SIM karta"</string>
    <string name="mobile_network_inactive_sim" msgid="291768076436646044">"Neaktivní / SIM karta"</string>
    <string name="mobile_network_active_esim" msgid="4914509039134228659">"Aktivní / stažená SIM karta"</string>
    <string name="mobile_network_inactive_esim" msgid="7653631389686307842">"Neaktivní / stažená SIM karta"</string>
    <string name="mobile_network_sim_name" msgid="5081645961314356327">"Název SIM karty"</string>
    <string name="mobile_network_sim_name_rename" msgid="7626733408098403107">"Přejmenovat"</string>
    <string name="mobile_network_use_sim_on" msgid="8035448244261570189">"Používat SIM kartu"</string>
    <string name="mobile_network_use_sim_off" msgid="889073420068380943">"Vypnuto"</string>
    <string name="mobile_network_esim_swap_confirm_title" msgid="6546784593612512953">"Přepnout na operátora <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="mobile_network_esim_swap_confirm_body" msgid="1621021150667547211">"V jednu chvíli může být aktivní pouze jedna stažená SIM karta.\n\nPřepnutím na operátora <xliff:g id="CARRIER1">%1$s</xliff:g> nezrušíte službu <xliff:g id="CARRIER2">%2$s</xliff:g>."</string>
    <string name="mobile_network_esim_swap_confirm_ok" msgid="8025086398614992834">"Přepnout na síť <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="896275511321635947">"Vymazat SIM kartu"</string>
    <string name="mobile_network_erase_sim_dialog_title" msgid="8211945787729023193">"Vymazat staženou SIM kartu?"</string>
    <string name="mobile_network_erase_sim_dialog_body" msgid="3363079846287650684">"Když vymažete tuto SIM kartu, ze zařízení bude odebrána služba <xliff:g id="CARRIER_0">%1$s</xliff:g>.\n\nSlužba operátora <xliff:g id="CARRIER_1">%2$s</xliff:g> zrušena nebude."</string>
    <string name="mobile_network_erase_sim_dialog_ok" msgid="5130805470041783437">"Vymazat"</string>
    <string name="mobile_network_erase_sim_dialog_progress" msgid="6541813899575453878">"Mazání SIM karty…"</string>
    <string name="mobile_network_erase_sim_error_dialog_title" msgid="730767308428197756">"SIM kartu nelze vymazat"</string>
    <string name="mobile_network_erase_sim_error_dialog_body" msgid="6835262809290075813">"Tuto SIM kartu nelze vymazat z důvodu chyby.\n\nRestartujte zařízení a zkuste to znovu."</string>
    <string name="preferred_network_mode_title" msgid="6505630109389684100">"Preferovaný typ sítě"</string>
    <string name="preferred_network_mode_summary" msgid="1216219115667163264">"Změnit provozní režim sítě"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="849254040214447984">"Preferovaný typ sítě"</string>
    <string name="carrier_settings_euicc" msgid="8658562169133242581">"Operátor"</string>
    <string name="carrier_settings_version" msgid="3469507893844448432">"Verze nastavení"</string>
    <string name="call_category" msgid="8108654745239563833">"Volání"</string>
    <string name="video_calling_settings_title" msgid="8153216918491498505">"Videohovory přes operátora"</string>
    <string name="cdma_system_select_title" msgid="7210256688912895790">"Výběr systému"</string>
    <string name="cdma_system_select_summary" msgid="3413863051181111941">"Změnit režim roamingu CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="1198883288864916563">"Výběr systému"</string>
    <string name="network_operator_category" msgid="8451238364605724918">"Síť"</string>
    <string name="network_select_title" msgid="8394621216255081026">"Síť"</string>
    <string name="cdma_subscription_title" msgid="1473189596933979467">"Odběr CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7191590908367194209">"Přepnout mezi RUIM/SIM a NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="9153005469617575361">"odběr"</string>
    <string name="register_automatically" msgid="518185886971595020">"Automatická registrace…"</string>
    <string name="roaming_alert_title" msgid="7458177294163751484">"Povolit datový roaming?"</string>
    <string name="roaming_check_price_warning" msgid="4979418631753681300">"Ceny vám sdělí poskytovatel datových služeb."</string>
    <string name="mobile_data_usage_title" msgid="7862429216994894656">"Využití dat aplikací"</string>
    <string name="mobile_network_mode_error" msgid="4784347953600013818">"Neplatný režim sítě <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignorovat."</string>
    <string name="mobile_network_apn_title" msgid="7610812642954395440">"Názvy přístupových bodů"</string>
    <string name="manual_mode_disallowed_summary" msgid="2085670341790561153">"Při připojení k operátorovi <xliff:g id="CARRIER">%1$s</xliff:g> nedostupné"</string>
    <string name="emergency_info_contextual_card_summary" msgid="7993926837251874514">"Zdravotní údaje, nouzové kontakty"</string>
    <string name="see_more" msgid="5953815986207345223">"Zobrazit další"</string>
    <string name="see_less" msgid="1250265310929558370">"Zobrazit méně"</string>
    <string name="network_connection_request_dialog_title" msgid="3502355504717957803">"Zařízení, které chcete používat s aplikací <xliff:g id="APPNAME">%1$s</xliff:g>"</string>
    <string name="network_connection_timeout_dialog_message" msgid="3711556077945728716">"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="8924405960181020156">"Zkusit znovu"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="6953778550775646710">"Něco se stalo. Aplikace zrušila požadavek na výběr zařízení."</string>
    <string name="network_connection_connect_successful" msgid="5935510954474494928">"Připojení úspěšně navázáno"</string>
    <string name="network_connection_request_dialog_showall" msgid="6938922880244567521">"Zobrazit vše"</string>
    <plurals name="show_bluetooth_devices" formatted="false" msgid="1715020480026568408">
      <item quantity="few"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> připojená zařízení</item>
      <item quantity="many"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> připojeného zařízení</item>
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> připojených zařízení</item>
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_0">%1$d</xliff:g> připojené zařízení</item>
    </plurals>
    <string name="no_bluetooth_devices" msgid="861861879657732058">"Žádná zařízení Bluetooth"</string>
    <string name="bluetooth_left_name" msgid="2133431890020995442">"Levé"</string>
    <string name="bluetooth_right_name" msgid="525578831502355410">"Pravé"</string>
    <string name="bluetooth_middle_name" msgid="3272836932362043957">"Hlavní díl"</string>
    <string name="settings_panel_title" msgid="4688575606213055744">"Panel nastavení"</string>
    <string name="internet_connectivity_panel_title" msgid="721392242301676444">"Připojení k internetu"</string>
    <string name="volume_connectivity_panel_title" msgid="9192664643867101356">"Hlasitost"</string>
    <string name="mobile_data_ap_mode_disabled" msgid="1127588179830051811">"V režimu Letadlo nedostupné"</string>
    <string name="force_desktop_mode" msgid="4303240595324847998">"Vynutit režim počítače"</string>
    <string name="force_desktop_mode_summary" msgid="6259798246015387202">"Vynutit na sekundárních displejích experimentální režim počítače"</string>
    <string name="hwui_force_dark_title" msgid="2466919877609396257">"Přepsat vynucení tmavého režimu"</string>
    <string name="hwui_force_dark_summary" msgid="8705328793382981780">"Přepíše vynucení stálého zapnutí tmavého režimu"</string>
    <string name="privacy_dashboard_title" msgid="2458407399263943923">"Ochrana soukromí"</string>
    <string name="privacy_dashboard_summary" msgid="4570241983077984329">"Oprávnění, aktivita na účtu, osobní údaje"</string>
    <string name="contextual_card_dismiss_remove" msgid="2813670241047194713">"Odstranit"</string>
    <string name="contextual_card_dismiss_keep" msgid="2230740610451447340">"Zachovat"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="5507487987591500742">"Odstranit tento návrh?"</string>
    <string name="contextual_card_removed_message" msgid="6744732110721136227">"Návrh byl odebrán"</string>
    <string name="contextual_card_undo_dismissal_text" msgid="3564089284222177020">"Zpět"</string>
    <string name="low_storage_summary" msgid="2077564126033530">"V úložišti je málo místa. 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="contextual_card_feedback_send" msgid="2996691837358030021">"Odeslat zpětnou vazbu"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="8115454795160804779">"Chtěli byste nám k tomuto návrhu poskytnout zpětnou vazbu?"</string>
    <string name="copyable_slice_toast" msgid="2924110841440836023">"<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="4718261366290530792"></string>
    <string name="permission_bar_chart_empty_text" msgid="4380731551728553852">"Oprávnění nepoužily žádné aplikace"</string>
    <string name="permission_bar_chart_title" msgid="2745425703472199837">"Využití oprávnění za posledních 24 hodin"</string>
    <string name="permission_bar_chart_details" msgid="2977943114535855210">"Zobrazit vše na panelu"</string>
    <plurals name="permission_bar_chart_label" formatted="false" msgid="5346938677887948252">
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> aplikace</item>
      <item quantity="many"><xliff:g id="NUMBER">%s</xliff:g> aplikace</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> aplikací</item>
      <item quantity="one">1 aplikace</item>
    </plurals>
    <string name="accessibility_usage_title" msgid="5136753034714150614">"Využití přístupnosti"</string>
    <plurals name="accessibility_usage_summary" formatted="false" msgid="5790789101231115740">
      <item quantity="few"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikace mají plný přístup k vašemu zařízení</item>
      <item quantity="many"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikace má plný přístup k vašemu zařízení</item>
      <item quantity="other"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikací má plný přístup k vašemu zařízení</item>
      <item quantity="one">1 aplikace má plný přístup k vašemu zařízení</item>
    </plurals>
    <string name="manage_app_notification" msgid="4575452737886198216">"Spravovat oznámení aplikace <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="no_suggested_app" msgid="5722034393216359231">"Není navrhována žádná aplikace"</string>
    <plurals name="notification_few_channel_count_summary" formatted="false" msgid="1090888820158822106">
      <item quantity="few"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_1">%1$d</xliff:g> kanály oznámení.</item>
      <item quantity="many"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_1">%1$d</xliff:g> kanálu oznámení.</item>
      <item quantity="other"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_1">%1$d</xliff:g> kanálů oznámení.</item>
      <item quantity="one"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_0">%1$d</xliff:g> kanál oznámení.</item>
    </plurals>
    <string name="notification_many_channel_count_summary" msgid="8647409434789898073">"Kanály oznámení: <xliff:g id="NOTIFICATION_CHANNEL_COUNT">%1$d</xliff:g>. Klepnutím můžete spravovat všechny."</string>
    <string name="recently_installed_app" msgid="2877671740090335492">"Tuto aplikaci jste nedávno nainstalovali."</string>
    <string name="media_output_panel_title" msgid="6197092814295528184">"Přepnout výstup"</string>
    <string name="media_output_panel_summary_of_playing_device" msgid="629529380940058789">"Právě se přehrává na zařízení <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wfc_disclaimer_title_text" msgid="6164569741719679613">"Důležité informace"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="1405773141236165542">"POKRAČOVAT"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="2700358281438736674">"NE, DĚKUJI"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="6658735446562619865">"Místo"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="3096546236221656018">"Poskytovatel služeb může za účelem plnění své role shromažďovat údaje o vaší poloze.\n\nProstudujte si zásady ochrany soukromí poskytovatele."</string>
    <string name="forget_passpoint_dialog_message" msgid="7331876195857622224">"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="keywords_content_capture" msgid="859132453327059493">"zachycení obsahu"</string>
    <string name="content_capture" msgid="6456873729933463600">"Zachycení obsahu"</string>
    <!-- no translation found for content_capture_summary (659506647507221852) -->
    <skip />
    <string name="capture_system_heap_dump_title" msgid="8043655498113164693">"Zaznamenat výpis haldy systému"</string>
    <string name="capturing_system_heap_dump_message" msgid="8680086369500395131">"Zaznamenávání výpisu haldy systému"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="6346229989760615103">"Výpis haldy systému se nepodařilo získat"</string>
    <string name="automatic_system_heap_dump_title" msgid="442496436397957988">"Automaticky zaznamenávat výpisy haldy systému"</string>
    <string name="automatic_system_heap_dump_summary" msgid="8253838659009241350">"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="2032651902928903819">"Odpojit"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="3354031536141983602">"Tísňová volání"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="6068582272230311464">"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>
</resources>
