<?xml version="1.0" encoding="UTF-8"?>
<!-- 
/* //device/apps/common/assets/res/any/strings.xml
**
** Copyright 2006, 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="byteShort" msgid="8340973892742019101">"B"</string>
    <string name="petabyteShort" msgid="5637816680144990219">"PB"</string>
    <string name="fileSizeSuffix" msgid="8897567456150907538">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="untitled" msgid="4638956954852782576">"&lt;Bez mena&gt;"</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(žiadne telefónne číslo)"</string>
    <string name="unknownName" msgid="6867811765370350269">"Bez názvu"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2660020990097733077">"Hlasová schránka"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2850889754919584674">"MSISDN1"</string>
    <string name="mmiError" msgid="5154499457739052907">"Problém s pripojením alebo neplatný kód MMI."</string>
    <string name="mmiFdnError" msgid="5224398216385316471">"Operácia je obmedzená len na povolené čísla."</string>
    <string name="mmiErrorWhileRoaming" msgid="762488890299284230">"Nastavenia presmerovania hovorov nie je možné zmeniť z telefónu počas roamingu."</string>
    <string name="serviceEnabled" msgid="8147278346414714315">"Služba bola povolená."</string>
    <string name="serviceEnabledFor" msgid="6856228140453471041">"Služba bola povolená pre:"</string>
    <string name="serviceDisabled" msgid="1937553226592516411">"Služba bola vypnutá."</string>
    <string name="serviceRegistered" msgid="6275019082598102493">"Registrácia prebehla úspešne."</string>
    <string name="serviceErased" msgid="1288584695297200972">"Vymazanie prebehlo úspešne."</string>
    <string name="passwordIncorrect" msgid="7612208839450128715">"Nesprávne heslo."</string>
    <string name="mmiComplete" msgid="8232527495411698359">"Funkcia MMI bola dokončená."</string>
    <string name="badPin" msgid="9015277645546710014">"Pôvodný kód PIN bol zadaný nesprávne."</string>
    <string name="badPuk" msgid="5487257647081132201">"Kód PUK bol zadaný nesprávne."</string>
    <string name="mismatchPin" msgid="609379054496863419">"Zadané kódy PIN sa nezhodujú."</string>
    <string name="invalidPin" msgid="3850018445187475377">"Zadajte kód PIN s dĺžkou 4 až 8 číslic."</string>
    <string name="invalidPuk" msgid="8761456210898036513">"Zadajte kód PUK, ktorý má 8 alebo viac čísel."</string>
    <string name="needPuk" msgid="919668385956251611">"SIM karta je uzamknutá pomocou kódu PUK. Odomknite ju zadaním kódu PUK."</string>
    <string name="needPuk2" msgid="4526033371987193070">"Ak chcete odblokovať SIM kartu, zadajte kód PUK2."</string>
    <string name="enablePin" msgid="209412020907207950">"Neúspešné, povoľte uzamknutie SIM/RUIM."</string>
    <plurals name="pinpuk_attempts" formatted="false" msgid="1251012001539225582">
      <item quantity="few">Zostávajú vám <xliff:g id="NUMBER_1">%d</xliff:g> pokusy, potom sa vaša SIM karta uzamkne.</item>
      <item quantity="many">Zostáva vám <xliff:g id="NUMBER_1">%d</xliff:g> pokusu, potom sa vaša SIM karta uzamkne.</item>
      <item quantity="other">Zostáva vám <xliff:g id="NUMBER_1">%d</xliff:g> pokusov, potom sa vaša SIM karta uzamkne.</item>
      <item quantity="one">Zostáva vám <xliff:g id="NUMBER_0">%d</xliff:g> pokus, potom sa vaša SIM karta uzamkne.</item>
    </plurals>
    <string name="imei" msgid="2625429890869005782">"IMEI"</string>
    <string name="meid" msgid="4841221237681254195">"MEID"</string>
    <string name="ClipMmi" msgid="6952821216480289285">"Prichádzajúca identifikácia volajúceho"</string>
    <string name="ClirMmi" msgid="7784673673446833091">"Odchádzajúca identifikácia volajúceho"</string>
    <string name="ColpMmi" msgid="3065121483740183974">"ID pripojenej linky"</string>
    <string name="ColrMmi" msgid="4996540314421889589">"Obmedzenie ID pripojenej linky"</string>
    <string name="CfMmi" msgid="5123218989141573515">"Presmerovanie hovorov"</string>
    <string name="CwMmi" msgid="9129678056795016867">"Čakajúci hovor"</string>
    <string name="BaMmi" msgid="455193067926770581">"Blokovanie hovorov"</string>
    <string name="PwdMmi" msgid="7043715687905254199">"Zmena hesla"</string>
    <string name="PinMmi" msgid="3113117780361190304">"Zmena kódu PIN"</string>
    <string name="CnipMmi" msgid="3110534680557857162">"Volané číslo uvedené"</string>
    <string name="CnirMmi" msgid="3062102121430548731">"Volanie čísla obmedzené"</string>
    <string name="ThreeWCMmi" msgid="9051047170321190368">"Konferencia troch účastníkov"</string>
    <string name="RuacMmi" msgid="7827887459138308886">"Odmietnutie nevyžiadaných obťažujúcich hovorov"</string>
    <string name="CndMmi" msgid="3116446237081575808">"Doručenie volaného čísla"</string>
    <string name="DndMmi" msgid="1265478932418334331">"Nerušiť"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="429415409145781923">"V predvolenom nastavení je identifikácia volajúceho obmedzená. Ďalší hovor: Obmedzené"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="3092918006077864624">"V predvolenom nastavení je identifikácia volajúceho obmedzená. Ďalší hovor: Bez obmedzenia"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="6179425182856418465">"V predvolenom nastavení nie je identifikácia volajúceho obmedzená. Ďalší hovor: Obmedzené"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2567998633124408552">"V predvolenom nastavení nie je identifikácia volajúceho obmedzená. Ďalší hovor: Bez obmedzenia"</string>
    <string name="serviceNotProvisioned" msgid="8614830180508686666">"Služba nie je poskytovaná."</string>
    <string name="CLIRPermanent" msgid="3377371145926835671">"Nemôžete meniť nastavenia identifikácie volajúceho."</string>
    <string name="RestrictedOnDataTitle" msgid="1322504692764166532">"Žiadna dátová služba"</string>
    <string name="RestrictedOnEmergencyTitle" msgid="3646729271176394091">"Žiadne tiesňové hovory"</string>
    <string name="RestrictedOnNormalTitle" msgid="3179574012752700984">"Žiadne hlasové hovory"</string>
    <string name="RestrictedOnAllVoiceTitle" msgid="158800171499150681">"Hlasové ani tiesňové volania nie sú k dispozícii"</string>
    <string name="RestrictedStateContent" msgid="4278821484643362350">"Momentálne nie sú v ponuke mobilnej siete na vašom mieste"</string>
    <string name="NetworkPreferenceSwitchTitle" msgid="4008877505368566980">"Nepodarilo sa pripojiť k sieti"</string>
    <string name="NetworkPreferenceSwitchSummary" msgid="1203771446683319957">"Ak chcete vylepšiť príjem, skúste zmeniť vybraný typ v časti Nastavenia &gt; Sieť a internet &gt; Mobilné siete &gt; Preferovaný typ siete."</string>
    <string name="EmergencyCallWarningTitle" msgid="4790413876281901612">"Volanie cez Wi‑Fi je aktívne"</string>
    <string name="EmergencyCallWarningSummary" msgid="8973232888021643293">"Tiesňové volania vyžadujú mobilnú sieť."</string>
    <string name="notification_channel_network_alert" msgid="4427736684338074967">"Upozornenia"</string>
    <string name="notification_channel_call_forward" msgid="2419697808481833249">"Presmerovanie hovorov"</string>
    <string name="notification_channel_emergency_callback" msgid="6686166232265733921">"Režim tiesňového spätného volania"</string>
    <string name="notification_channel_mobile_data_status" msgid="4575131690860945836">"Stav mobilných dát"</string>
    <string name="notification_channel_sms" msgid="3441746047346135073">"Správy SMS"</string>
    <string name="notification_channel_voice_mail" msgid="3954099424160511919">"Správy hlasovej schránky"</string>
    <string name="notification_channel_wfc" msgid="2130802501654254801">"Volanie cez Wi‑Fi"</string>
    <string name="peerTtyModeFull" msgid="6165351790010341421">"Používateľ, s ktorým komunikujete, požiadal o režim FULL textového telefónu"</string>
    <string name="peerTtyModeHco" msgid="5728602160669216784">"Používateľ, s ktorým komunikujete, požiadal o režim HCO textového telefónu"</string>
    <string name="peerTtyModeVco" msgid="1742404978686538049">"Používateľ, s ktorým komunikujete, požiadal o režim VCO textového telefónu"</string>
    <string name="peerTtyModeOff" msgid="3280819717850602205">"Používateľ, s ktorým komunikujete, požiadal o režim OFF textového telefónu"</string>
    <string name="serviceClassVoice" msgid="1258393812335258019">"Voice"</string>
    <string name="serviceClassData" msgid="872456782077937893">"Dáta"</string>
    <string name="serviceClassFAX" msgid="5566624998840486475">"FAX"</string>
    <string name="serviceClassSMS" msgid="2015460373701527489">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="4523454783498551468">"Async"</string>
    <string name="serviceClassDataSync" msgid="7530000519646054776">"Synchronizovať"</string>
    <string name="serviceClassPacket" msgid="6991006557993423453">"Pakety"</string>
    <string name="serviceClassPAD" msgid="3235259085648271037">"PAD"</string>
    <string name="roamingText0" msgid="7170335472198694945">"Indikátor roamingu svieti"</string>
    <string name="roamingText1" msgid="5314861519752538922">"Indikátor roamingu nesvieti"</string>
    <string name="roamingText2" msgid="8969929049081268115">"Indikátor roamingu bliká"</string>
    <string name="roamingText3" msgid="5148255027043943317">"Nie je v blízkosti"</string>
    <string name="roamingText4" msgid="8808456682550796530">"Mimo budovy"</string>
    <string name="roamingText5" msgid="7604063252850354350">"Roaming – preferovaný systém"</string>
    <string name="roamingText6" msgid="2059440825782871513">"Roaming – dostupný systém"</string>
    <string name="roamingText7" msgid="7112078724097233605">"Roaming – aliančný partner"</string>
    <string name="roamingText8" msgid="5989569778604089291">"Roaming – prémiový partner"</string>
    <string name="roamingText9" msgid="7969296811355152491">"Roaming – úplná funkčnosť služby"</string>
    <string name="roamingText10" msgid="3992906999815316417">"Roaming – čiastočná funkčnosť služby"</string>
    <string name="roamingText11" msgid="4154476854426920970">"Banner roamingu je zapnutý"</string>
    <string name="roamingText12" msgid="1189071119992726320">"Banner roamingu je vypnutý"</string>
    <string name="roamingTextSearching" msgid="8360141885972279963">"Vyhľadávanie služby"</string>
    <string name="wfcRegErrorTitle" msgid="2301376280632110664">"Volanie cez Wi‑Fi"</string>
  <string-array name="wfcOperatorErrorAlertMessages">
    <item msgid="3910386316304772394">"Ak chcete volať a odosielať správy prostredníctvom siete Wi‑Fi, kontaktujte najskôr svojho operátora v súvislosti s nastavením tejto služby. Potom opäť zapnite v Nastaveniach volanie cez Wi‑Fi. (Kód chyby: <xliff:g id="CODE">%1$s</xliff:g>)"</item>
  </string-array>
  <string-array name="wfcOperatorErrorNotificationMessages">
    <item msgid="7472393097168811593">"Zaregistrujte sa u operátora (Kód chyby: <xliff:g id="CODE">%1$s</xliff:g>)"</item>
  </string-array>
  <string-array name="wfcSpnFormats">
    <item msgid="6830082633573257149">"%s"</item>
    <item msgid="4397097370387921767">"Volanie siete Wi‑Fi %s"</item>
  </string-array>
    <string name="wifi_calling_off_summary" msgid="8720659586041656098">"Vypnuté"</string>
    <string name="wfc_mode_wifi_preferred_summary" msgid="1994113411286935263">"Uprednostniť Wi‑Fi"</string>
    <string name="wfc_mode_cellular_preferred_summary" msgid="1988279625335345908">"Preferujem mobilné dáta"</string>
    <string name="wfc_mode_wifi_only_summary" msgid="2379919155237869320">"Len Wi‑Fi"</string>
    <string name="cfTemplateNotForwarded" msgid="1683685883841272560">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nepresmerované"</string>
    <string name="cfTemplateForwarded" msgid="1302922117498590521">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g>"</string>
    <string name="cfTemplateForwardedTime" msgid="9206251736527085256">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g> po <xliff:g id="TIME_DELAY">{2}</xliff:g> s"</string>
    <string name="cfTemplateRegistered" msgid="5073237827620166285">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nepresmerované"</string>
    <string name="cfTemplateRegisteredTime" msgid="6781621964320635172">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nepresmerované"</string>
    <string name="fcComplete" msgid="3118848230966886575">"Požiadavka zadaná pomocou kódu funkcie bola úspešne dokončená."</string>
    <string name="fcError" msgid="3327560126588500777">"Problém s pripojením alebo neplatný kód funkcie."</string>
    <string name="httpErrorOk" msgid="1191919378083472204">"OK"</string>
    <string name="httpError" msgid="7956392511146698522">"Vyskytla sa chyba siete."</string>
    <string name="httpErrorLookup" msgid="4711687456111963163">"Webovú adresu sa nepodarilo nájsť."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="6299980280442076799">"Schéma overenia webových stránok nie je podporovaná."</string>
    <string name="httpErrorAuth" msgid="1435065629438044534">"Nepodarilo sa overiť totožnosť."</string>
    <string name="httpErrorProxyAuth" msgid="1788207010559081331">"Overenie pomocou servera proxy bolo neúspešné."</string>
    <string name="httpErrorConnect" msgid="8714273236364640549">"K serveru sa nepodarilo pripojiť."</string>
    <string name="httpErrorIO" msgid="2340558197489302188">"Nepodarilo sa nadviazať komunikáciu so serverom. Skúste to znova neskôr."</string>
    <string name="httpErrorTimeout" msgid="4743403703762883954">"Časový limit pripojenia na server vypršal."</string>
    <string name="httpErrorRedirectLoop" msgid="8679596090392779516">"Stránka obsahuje príliš veľa presmerovaní servera."</string>
    <string name="httpErrorUnsupportedScheme" msgid="5015730812906192208">"Protokol nie je podporovaný."</string>
    <string name="httpErrorFailedSslHandshake" msgid="96549606000658641">"Zabezpečené spojenie sa nepodarilo nadviazať."</string>
    <string name="httpErrorBadUrl" msgid="3636929722728881972">"Stránku sa nepodarilo otvoriť pretože webová adresa je neplatná."</string>
    <string name="httpErrorFile" msgid="2170788515052558676">"Prístup k súboru sa nepodarilo získať."</string>
    <string name="httpErrorFileNotFound" msgid="6203856612042655084">"Požadovaný súbor sa nepodarilo nájsť."</string>
    <string name="httpErrorTooManyRequests" msgid="1235396927087188253">"Je spracovávaných príliš veľa žiadostí. Opakujte akciu neskôr."</string>
    <string name="notification_title" msgid="8967710025036163822">"Chyba prihlásenia do účtu <xliff:g id="ACCOUNT">%1$s</xliff:g>"</string>
    <string name="contentServiceSync" msgid="8353523060269335667">"Synchronizovať"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="397743349191901458">"Synchronizovať"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="8100981435080696431">"Príliš veľa odstránených položiek služby <xliff:g id="CONTENT_TYPE">%s</xliff:g>."</string>
    <string name="low_memory" product="tablet" msgid="6494019234102154896">"Ukladací priestor tabletu je plný. Odstráňte niektoré súbory a uvoľnite miesto."</string>
    <string name="low_memory" product="watch" msgid="4415914910770005166">"Ukladací priestor hodiniek je plný. Uvoľnite miesto odstránením niektorých súborov."</string>
    <string name="low_memory" product="tv" msgid="516619861191025923">"Úložisko televízora je plné. Uvoľnite miesto odstránením niektorých súborov."</string>
    <string name="low_memory" product="default" msgid="3475999286680000541">"Pamäť telefónu je plná. Odstráňte niektoré súbory a uvoľnite miesto."</string>
    <plurals name="ssl_ca_cert_warning" formatted="false" msgid="5106721205300213569">
      <item quantity="few">Boli nainštalované certifikačné autority</item>
      <item quantity="many">Boli nainštalované certifikačné autority</item>
      <item quantity="other">Boli nainštalované certifikačné autority</item>
      <item quantity="one">Bola nainštalovaná certifikačná autorita</item>
    </plurals>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4475437862189850602">"Neznámou treťou stranou"</string>
    <string name="ssl_ca_cert_noti_by_administrator" msgid="3541729986326153557">"Správcom vášho pracovného profilu"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="4030263497686867141">"Doménou <xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="work_profile_deleted" msgid="5005572078641980632">"Pracovný profil bol odstránený"</string>
    <string name="work_profile_deleted_description" msgid="1100529432509639864">"Pracovný profil bol odstránený z dôvodu chýbajúcej aplikácie na správu"</string>
    <string name="work_profile_deleted_details" msgid="6307630639269092360">"Aplikácia na správu pracovného profilu buď chýba, alebo je poškodená. Z toho dôvodu bol odstránený pracovný profil aj k nemu priradené dáta. Ak potrebujete pomoc, kontaktujte svojho správcu."</string>
    <string name="work_profile_deleted_description_dpm_wipe" msgid="8823792115612348820">"Váš pracovný profil už v tomto zariadení nie je k dispozícii"</string>
    <string name="network_logging_notification_title" msgid="6399790108123704477">"Zariadenie je spravované"</string>
    <string name="network_logging_notification_text" msgid="7930089249949354026">"Vaša organizácia spravuje toto zariadenie a môže sledovať sieťovú premávku. Klepnutím zobrazíte podrobnosti."</string>
    <string name="factory_reset_warning" msgid="5423253125642394387">"Vaše zariadenie bude vymazané"</string>
    <string name="factory_reset_message" msgid="7972496262232832457">"Daná aplikácia na správu sa nedá použiť. Vaše zariadenie bude vymazané.\n\nV prípade otázok kontaktujte správcu organizácie."</string>
    <string name="me" msgid="6545696007631404292">"Ja"</string>
    <string name="power_dialog" product="tablet" msgid="8545351420865202853">"Možnosti tabletu"</string>
    <string name="power_dialog" product="tv" msgid="6153888706430556356">"Možnosti televízora"</string>
    <string name="power_dialog" product="default" msgid="1319919075463988638">"Možnosti telefónu"</string>
    <string name="silent_mode" msgid="7167703389802618663">"Tichý režim"</string>
    <string name="turn_on_radio" msgid="3912793092339962371">"Zapnúť bezdrôtové pripojenie"</string>
    <string name="turn_off_radio" msgid="8198784949987062346">"Vypnúť bezdrôtové pripojenie"</string>
    <string name="screen_lock" msgid="799094655496098153">"Zámka obrazovky"</string>
    <string name="power_off" msgid="4266614107412865048">"Vypnúť"</string>
    <string name="silent_mode_silent" msgid="319298163018473078">"Zvonenie je vypnuté"</string>
    <string name="silent_mode_vibrate" msgid="7072043388581551395">"Vibračné zvonenie"</string>
    <string name="silent_mode_ring" msgid="8592241816194074353">"Zvonenie je zapnuté"</string>
    <string name="reboot_to_update_title" msgid="6212636802536823850">"Aktualizácia systému Android"</string>
    <string name="reboot_to_update_prepare" msgid="6305853831955310890">"Pripravuje sa aktualizácia…"</string>
    <string name="reboot_to_update_package" msgid="3871302324500927291">"Spracováva sa balík aktualizácií…"</string>
    <string name="reboot_to_update_reboot" msgid="6428441000951565185">"Reštartuje sa…"</string>
    <string name="reboot_to_reset_title" msgid="4142355915340627490">"Obnovenie výrobných nastavení"</string>
    <string name="reboot_to_reset_message" msgid="2432077491101416345">"Reštartuje sa…"</string>
    <string name="shutdown_progress" msgid="2281079257329981203">"Prebieha vypínanie..."</string>
    <string name="shutdown_confirm" product="tablet" msgid="3385745179555731470">"Váš tablet bude vypnutý."</string>
    <string name="shutdown_confirm" product="tv" msgid="476672373995075359">"Televízor sa vypne."</string>
    <string name="shutdown_confirm" product="watch" msgid="3490275567476369184">"Hodinky sa vypnú."</string>
    <string name="shutdown_confirm" product="default" msgid="649792175242821353">"Váš telefón bude vypnutý."</string>
    <string name="shutdown_confirm_question" msgid="2906544768881136183">"Chcete zariadenie vypnúť?"</string>
    <string name="reboot_safemode_title" msgid="7054509914500140361">"Reštartovať do núdzového režimu"</string>
    <string name="reboot_safemode_confirm" msgid="55293944502784668">"Chcete zariadenie reštartovať do núdzového režimu? Zakážu sa tým všetky aplikácie tretích strán, ktoré ste nainštalovali. Tieto aplikácie budú obnovené po ďalšom reštartovaní."</string>
    <string name="recent_tasks_title" msgid="3691764623638127888">"Najnovšie"</string>
    <string name="no_recent_tasks" msgid="8794906658732193473">"Žiadne nedávne aplikácie"</string>
    <string name="global_actions" product="tablet" msgid="408477140088053665">"Možnosti tabletu"</string>
    <string name="global_actions" product="tv" msgid="7240386462508182976">"Možnosti televízora"</string>
    <string name="global_actions" product="default" msgid="2406416831541615258">"Možnosti telefónu"</string>
    <string name="global_action_lock" msgid="2844945191792119712">"Zámka obrazovky"</string>
    <string name="global_action_power_off" msgid="4471879440839879722">"Vypnúť"</string>
    <string name="global_action_emergency" msgid="7112311161137421166">"Tiesňové volanie"</string>
    <string name="global_action_bug_report" msgid="7934010578922304799">"Hlásenie o chybách"</string>
    <string name="bugreport_title" msgid="2667494803742548533">"Vytvoriť hlásenie chyby"</string>
    <string name="bugreport_message" msgid="398447048750350456">"Týmto zhromaždíte informácie o aktuálnom stave zariadenia. Informácie je potom možné odoslať e-mailom, chvíľu však potrvá, kým bude hlásenie chyby pripravené na odoslanie. Prosíme vás preto o trpezlivosť."</string>
    <string name="bugreport_option_interactive_title" msgid="8635056131768862479">"Interaktívne nahlásenie"</string>
    <string name="bugreport_option_interactive_summary" msgid="229299488536107968">"Táto možnosť je vhodná pre väčšinu prípadov. Umožňuje sledovať priebeh nahlásenia, zadávať ďalšie podrobnosti o probléme a vytvárať snímky obrazovky. Môžu byť vynechané niektoré menej používané sekcie, ktorých nahlásenie trvá dlho."</string>
    <string name="bugreport_option_full_title" msgid="6354382025840076439">"Úplné nahlásenie"</string>
    <string name="bugreport_option_full_summary" msgid="7210859858969115745">"Táto možnosť slúži na minimalizáciu zásahov do systému, keď zariadenie neodpovedá, je príliš pomalé alebo potrebujete zahrnúť všetky sekcie hlásenia. Neumožňuje zadať ďalšie podrobnosti ani vytvoriť dodatočné snímky obrazovky."</string>
    <plurals name="bugreport_countdown" formatted="false" msgid="6878900193900090368">
      <item quantity="few">Snímka obrazovky pre hlásenie chyby sa vytvorí o <xliff:g id="NUMBER_1">%d</xliff:g> sekundy.</item>
      <item quantity="many">Snímka obrazovky pre hlásenie chyby sa vytvorí o <xliff:g id="NUMBER_1">%d</xliff:g> sekundy.</item>
      <item quantity="other">Snímka obrazovky pre hlásenie chyby sa vytvorí o <xliff:g id="NUMBER_1">%d</xliff:g> sekúnd.</item>
      <item quantity="one">Snímka obrazovky pre hlásenie chyby sa vytvorí o <xliff:g id="NUMBER_0">%d</xliff:g> sekundu.</item>
    </plurals>
    <string name="global_action_toggle_silent_mode" msgid="8219525344246810925">"Tichý režim"</string>
    <string name="global_action_silent_mode_on_status" msgid="3289841937003758806">"Zvuk je VYPNUTÝ."</string>
    <string name="global_action_silent_mode_off_status" msgid="1506046579177066419">"Zvuk je zapnutý"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="5884330306926307456">"Režim v lietadle"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="2719557982608919750">"Režim v lietadle je ZAPNUTÝ"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="5075070442854490296">"Režim v lietadle je VYPNUTÝ"</string>
    <string name="global_action_settings" msgid="1756531602592545966">"Nastavenia"</string>
    <string name="global_action_assist" msgid="3892832961594295030">"Pomôcť"</string>
    <string name="global_action_voice_assist" msgid="7751191495200504480">"Hlasový asistent"</string>
    <string name="global_action_lockdown" msgid="8751542514724332873">"Uzamknúť"</string>
    <string name="status_bar_notification_info_overflow" msgid="5301981741705354993">"999+"</string>
    <string name="notification_hidden_text" msgid="6351207030447943784">"Nové upozornenie"</string>
    <string name="notification_channel_virtual_keyboard" msgid="6969925135507955575">"Virtuálna klávesnica"</string>
    <string name="notification_channel_physical_keyboard" msgid="7297661826966861459">"Fyzická klávesnica"</string>
    <string name="notification_channel_security" msgid="7345516133431326347">"Zabezpečenie"</string>
    <string name="notification_channel_car_mode" msgid="3553380307619874564">"Režim v aute"</string>
    <string name="notification_channel_account" msgid="7577959168463122027">"Stav účtu"</string>
    <string name="notification_channel_developer" msgid="7579606426860206060">"Správy pre vývojárov"</string>
    <string name="notification_channel_updates" msgid="4794517569035110397">"Aktualizácie"</string>
    <string name="notification_channel_network_status" msgid="5025648583129035447">"Stav siete"</string>
    <string name="notification_channel_network_alerts" msgid="2895141221414156525">"Upozornenia týkajúce sa siete"</string>
    <string name="notification_channel_network_available" msgid="4531717914138179517">"Sieť je k dispozícii"</string>
    <string name="notification_channel_vpn" msgid="8330103431055860618">"Stav pripojenia VPN"</string>
    <string name="notification_channel_device_admin" msgid="1568154104368069249">"Správa zariadenia"</string>
    <string name="notification_channel_alerts" msgid="4496839309318519037">"Upozornenia"</string>
    <string name="notification_channel_retail_mode" msgid="6088920674914038779">"Predajná ukážka"</string>
    <string name="notification_channel_usb" msgid="9006850475328924681">"Pripojenie USB"</string>
    <string name="notification_channel_foreground_service" msgid="3931987440602669158">"Aplikácie spotrebúvajú batériu"</string>
    <string name="foreground_service_app_in_background" msgid="1060198778219731292">"<xliff:g id="APP_NAME">%1$s</xliff:g> používa batériu"</string>
    <string name="foreground_service_apps_in_background" msgid="7175032677643332242">"Aplikácie (<xliff:g id="NUMBER">%1$d</xliff:g>) používajú batériu"</string>
    <string name="foreground_service_tap_for_details" msgid="372046743534354644">"Klepnutím zobrazíte podrobnosti o batérii a spotrebe dát"</string>
    <string name="foreground_service_multiple_separator" msgid="4021901567939866542">"<xliff:g id="LEFT_SIDE">%1$s</xliff:g>, <xliff:g id="RIGHT_SIDE">%2$s</xliff:g>"</string>
    <string name="safeMode" msgid="2788228061547930246">"Núdzový režim"</string>
    <string name="android_system_label" msgid="6577375335728551336">"Systém Android"</string>
    <string name="user_owner_label" msgid="1119010402169916617">"Prepnúť na osobný"</string>
    <string name="managed_profile_label" msgid="5289992269827577857">"Prepnúť na pracovný"</string>
    <string name="permgrouplab_contacts" msgid="3657758145679177612">"Kontakty"</string>
    <string name="permgroupdesc_contacts" msgid="6951499528303668046">"prístup ku kontaktom"</string>
    <string name="permgrouplab_location" msgid="7275582855722310164">"Poloha"</string>
    <string name="permgroupdesc_location" msgid="1346617465127855033">"prístup k polohe tohto zariadenia"</string>
    <string name="permgrouplab_calendar" msgid="5863508437783683902">"Kalendár"</string>
    <string name="permgroupdesc_calendar" msgid="3889615280211184106">"prístup ku kalendáru"</string>
    <string name="permgrouplab_sms" msgid="228308803364967808">"SMS"</string>
    <string name="permgroupdesc_sms" msgid="4656988620100940350">"posielanie a zobrazovanie SMS"</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Úložisko"</string>
    <string name="permgroupdesc_storage" msgid="637758554581589203">"prístup k fotkám, médiám a súborom v zariadení"</string>
    <string name="permgrouplab_microphone" msgid="171539900250043464">"Mikrofón"</string>
    <string name="permgroupdesc_microphone" msgid="4988812113943554584">"nahrávanie zvuku"</string>
    <string name="permgrouplab_camera" msgid="4820372495894586615">"Fotoaparát"</string>
    <string name="permgroupdesc_camera" msgid="3250611594678347720">"fotenie a natáčanie videí"</string>
    <string name="permgrouplab_phone" msgid="5229115638567440675">"Telefón"</string>
    <string name="permgroupdesc_phone" msgid="6234224354060641055">"telefonovanie a správu hovorov"</string>
    <string name="permgrouplab_sensors" msgid="416037179223226722">"Telesné senzory"</string>
    <string name="permgroupdesc_sensors" msgid="7147968539346634043">"prístup k dátam senzorov vašich životných funkcií"</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="3901717936930170320">"Načítať obsah okna"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="3772225008605310672">"Môžete preskúmať obsah okna, s ktorým pracujete."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="3108723364676667320">"Zapnúť funkciu Preskúmanie dotykom"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="7543249041581408313">"Po klepnutí na položku sa vysloví jej názov a obrazovku je možné preskúmať pomocou gest."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2103440391902412174">"Sledovať zadávaný text"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="7463135292204152818">"Sledovanie zahŕňa osobné údaje ako sú čísla kreditných kariet a heslá."</string>
    <string name="capability_title_canControlMagnification" msgid="3593493281059424855">"Ovládanie priblíženia obrazovky"</string>
    <string name="capability_desc_canControlMagnification" msgid="4791858203568383773">"Ovládajte umiestnenie a úroveň priblíženia obrazovky."</string>
    <string name="capability_title_canPerformGestures" msgid="7418984730362576862">"Gestá"</string>
    <string name="capability_desc_canPerformGestures" msgid="8296373021636981249">"Je možné použiť klepnutie, prejdenie, stiahnutie prstami a ďalšie gestá."</string>
    <string name="capability_title_canCaptureFingerprintGestures" msgid="6309568287512278670">"Gestá odtlačkov prstov"</string>
    <string name="capability_desc_canCaptureFingerprintGestures" msgid="7102111919385702482">"Dokáže zaznamenať gestá vykonané na senzore odtlačkov prstov."</string>
    <string name="permlab_statusBar" msgid="7417192629601890791">"zakázanie alebo zmeny stavového riadka"</string>
    <string name="permdesc_statusBar" msgid="8434669549504290975">"Umožňuje aplikácii vypnúť stavový riadok alebo pridať a odstrániť systémové ikony."</string>
    <string name="permlab_statusBarService" msgid="4826835508226139688">"vydávanie sa za stavový riadok"</string>
    <string name="permdesc_statusBarService" msgid="716113660795976060">"Umožňuje aplikácii fungovať ako stavový riadok."</string>
    <string name="permlab_expandStatusBar" msgid="1148198785937489264">"rozbalenie a zbalenie stavového riadka"</string>
    <string name="permdesc_expandStatusBar" msgid="6917549437129401132">"Umožňuje aplikácii rozbaliť alebo zbaliť stavový riadok."</string>
    <string name="permlab_install_shortcut" msgid="4279070216371564234">"inštalovať odkazy"</string>
    <string name="permdesc_install_shortcut" msgid="8341295916286736996">"Povoľuje aplikácii pridať odkazy na ploche bez zásahu používateľa."</string>
    <string name="permlab_uninstall_shortcut" msgid="4729634524044003699">"odinštalovať odkazy"</string>
    <string name="permdesc_uninstall_shortcut" msgid="6745743474265057975">"Povoľuje aplikácii odstrániť odkazy na ploche bez zásahu používateľa."</string>
    <string name="permlab_processOutgoingCalls" msgid="3906007831192990946">"presmerovať odchádzajúce hovory"</string>
    <string name="permdesc_processOutgoingCalls" msgid="5156385005547315876">"Umožňuje aplikácii počas odchádzajúceho hovoru rozpoznať vytáčané číslo a poskytuje možnosť presmerovať daný hovor na odlišné číslo alebo ho úplne zrušiť."</string>
    <string name="permlab_answerPhoneCalls" msgid="4077162841226223337">"odpovedanie na telefonické hovory"</string>
    <string name="permdesc_answerPhoneCalls" msgid="2901889867993572266">"Umožňuje aplikácii odpovedať na prichádzajúce telefonáty."</string>
    <string name="permlab_receiveSms" msgid="8673471768947895082">"prijímať textové správy (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="6424387754228766939">"Umožňuje aplikácii prijímať a spracovávať správy SMS. Znamená to, že aplikácia môže sledovať správy odoslané na vaše zariadenie alebo ich odstrániť bez toho, aby sa vám zobrazili."</string>
    <string name="permlab_receiveMms" msgid="1821317344668257098">"prijímať textové správy (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="533019437263212260">"Umožňuje aplikácii prijímať a spracovávať správy MMS. Znamená to, že aplikácia môže sledovať správy odoslané na vaše zariadenie alebo ich odstrániť bez toho, aby sa vám zobrazili."</string>
    <string name="permlab_readCellBroadcasts" msgid="1598328843619646166">"čítať správy informačných služieb"</string>
    <string name="permdesc_readCellBroadcasts" msgid="6361972776080458979">"Umožňuje aplikácii čítať správy informačných služieb prijaté vaším zariadením. Správy informačných služieb sa doručujú na určitých miestach a upozorňujú na tiesňové situácie. Škodlivé aplikácie môžu pri prijatí správy informačnej služby narušiť výkonnosť alebo prevádzku vášho zariadenia."</string>
    <string name="permlab_subscribedFeedsRead" msgid="4756609637053353318">"čítať odoberané informačné kanály"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="5557058907906144505">"Umožňuje aplikácii získať podrobnosti o aktuálne synchronizovaných informačných kanáloch."</string>
    <string name="permlab_sendSms" msgid="7544599214260982981">"posielať a zobrazovať SMS"</string>
    <string name="permdesc_sendSms" msgid="7094729298204937667">"Umožňuje aplikácii odosielať správy SMS. Môže to mať za následok účtovanie neočakávaných poplatkov. Škodlivé aplikácie vám môžu spôsobiť výdavky odosielaním správ bez vášho potvrdenia."</string>
    <string name="permlab_readSms" msgid="8745086572213270480">"čítať textové správy (SMS alebo MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="4741697454888074891">"Táto aplikácia môže čítať všetky textové správy (SMS) uložené vo vašom tablete."</string>
    <string name="permdesc_readSms" product="tv" msgid="5796670395641116592">"Táto aplikácia môže čítať všetky textové správy (SMS) uložené vo vašom televízore."</string>
    <string name="permdesc_readSms" product="default" msgid="6826832415656437652">"Táto aplikácia môže čítať všetky textové správy (SMS) uložené vo vašom telefóne."</string>
    <string name="permlab_receiveWapPush" msgid="5991398711936590410">"prijímať textové správy (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="748232190220583385">"Umožňuje aplikácii prijímať a spracovávať správy WAP. Toto povolenie zahŕňa možnosť sledovať vaše správy alebo ich odstrániť bez toho, aby sa vám zobrazili."</string>
    <string name="permlab_getTasks" msgid="6466095396623933906">"načítať spustené aplikácie"</string>
    <string name="permdesc_getTasks" msgid="7454215995847658102">"Umožňuje aplikácii načítať informácie o aktuálne či nedávno spustených úlohách. Toto povolenie môže aplikácii umožniť objaviť informácie o tom, ktoré aplikácie sa na zariadení používajú."</string>
    <string name="permlab_manageProfileAndDeviceOwners" msgid="7918181259098220004">"správa vlastníkov profilov a zariadení"</string>
    <string name="permdesc_manageProfileAndDeviceOwners" msgid="106894851498657169">"Povolí aplikáciám nastaviť vlastníkov profilov a vlastníka zariadenia."</string>
    <string name="permlab_reorderTasks" msgid="2018575526934422779">"zmeniť poradie spustených aplikácií"</string>
    <string name="permdesc_reorderTasks" msgid="7734217754877439351">"Umožňuje aplikácii presunúť úlohy do popredia alebo do pozadia. Aplikácia tak môže urobiť bez vášho zásahu."</string>
    <string name="permlab_enableCarMode" msgid="5684504058192921098">"aktivovať režim V aute"</string>
    <string name="permdesc_enableCarMode" msgid="4853187425751419467">"Umožňuje aplikácii povoliť režim V aute."</string>
    <string name="permlab_killBackgroundProcesses" msgid="3914026687420177202">"zavrieť iné aplikácie"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="4593353235959733119">"Umožňuje aplikácii ukončiť procesy na pozadí ostatných aplikácií. Môže to zapríčiniť zastavenie ostatných aplikácií."</string>
    <string name="permlab_systemAlertWindow" msgid="7238805243128138690">"Táto aplikácia sa môže zobraziť nad ostatnými aplikáciami"</string>
    <string name="permdesc_systemAlertWindow" msgid="2393776099672266188">"Táto aplikácia sa môže zobraziť nad ostatnými aplikáciami alebo ďalšími časťami obrazovky. Môže tak narušovať normálne používanie aplikácií a zmeniť spôsob zobrazenia ďalších aplikácií."</string>
    <string name="permlab_runInBackground" msgid="7365290743781858803">"spustenie na pozadí"</string>
    <string name="permdesc_runInBackground" msgid="7370142232209999824">"Táto aplikácia sa môže spustiť na pozadí a rýchlejšie tak vybiť batériu."</string>
    <string name="permlab_useDataInBackground" msgid="8694951340794341809">"využívanie dát na pozadí"</string>
    <string name="permdesc_useDataInBackground" msgid="6049514223791806027">"Táto aplikácia môže využívať dáta na pozadí a zvýšiť tak spotrebu dát."</string>
    <string name="permlab_persistentActivity" msgid="8841113627955563938">"nastaviť, aby bola aplikácia neustále spustená"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="8525189272329086137">"Umožňuje aplikácii uložiť niektoré svoje časti natrvalo do pamäte. Môže to obmedziť pamäť dostupnú pre ostatné aplikácie a spomaliť tak tablet."</string>
    <string name="permdesc_persistentActivity" product="tv" msgid="5086862529499103587">"Umožňuje aplikácii natrvalo uložiť svoje časti v pamäti. Môže to obmedziť pamäť dostupnú pre ďalšie aplikácie, čím sa spomaľuje televízor."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="4384760047508278272">"Umožňuje aplikácii uložiť niektoré svoje časti natrvalo do pamäte. Môže to obmedziť pamäť dostupnú pre ostatné aplikácie a spomaliť tak telefón."</string>
    <string name="permlab_getPackageSize" msgid="7472921768357981986">"zistiť veľkosť ukladacieho priestoru aplikácie"</string>
    <string name="permdesc_getPackageSize" msgid="3921068154420738296">"Umožňuje aplikácii načítať svoj kód, údaje a veľkosti vyrovnávacej pamäte"</string>
    <string name="permlab_writeSettings" msgid="2226195290955224730">"upraviť nastavenia systému"</string>
    <string name="permdesc_writeSettings" msgid="7775723441558907181">"Umožňuje aplikácii zmeniť údaje nastavení systému. Škodlivé aplikácie môžu poškodiť konfiguráciu vášho systému."</string>
    <string name="permlab_receiveBootCompleted" msgid="5312965565987800025">"spustiť pri štarte"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="7390304664116880704">"Umožňuje aplikácii spustiť sa hneď po spustení systému. Toto nastavenie môže spomaliť spustenie tabletu a tiež jeho celkový výkon, pretože aplikácia bude neustále spustená."</string>
    <string name="permdesc_receiveBootCompleted" product="tv" msgid="4525890122209673621">"Umožňuje aplikácii spustiť sa ihneď po dokončení spustenia systému. Toto nastavenie môže spôsobiť pomalšie spúšťanie televízora a umožňuje aplikácii celkovo spomaliť výkon, pretože bude neustále spustená."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="513950589102617504">"Umožňuje aplikácii okamžité spustenie po spustení systému. Toto nastavenie môže spomaliť spustenie tabletu a tiež celkový výkon tabletu, pretože aplikácia bude neustále zapnutá."</string>
    <string name="permlab_broadcastSticky" msgid="7919126372606881614">"odoslanie trvalého vysielania"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="7749760494399915651">"Umožňuje aplikácii odosielať trvalé vysielania, ktoré pretrvávajú aj po skončení vysielania. Nadmerné používanie môže tablet spomaliť alebo spôsobiť jeho nestabilitu, pretože bude používať príliš veľa pamäte."</string>
    <string name="permdesc_broadcastSticky" product="tv" msgid="6839285697565389467">"Umožňuje aplikácii odosielať pútavé programy, ktoré zostanú uchované aj po skočení vysielania. Nadmerné používanie môže televíznu reláciu spomaliť alebo narušiť jej stabilitu, pretože ju prinúti používať príliš veľa pamäte."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="2825803764232445091">"Umožňuje aplikácii odosielať trvalé vysielania, ktoré pretrvávajú aj po skončení vysielania. Nadmerné používanie môže telefón spomaliť alebo spôsobiť jeho nestabilitu, pretože bude používať príliš veľa pamäte."</string>
    <string name="permlab_readContacts" msgid="8348481131899886131">"čítať kontakty"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="5294866856941149639">"Umožňuje aplikácii čítať údaje o kontaktoch uložených v tablete vrátane informácií o frekvencii vašich telefonátov, odoslaných e-mailov alebo iných foriem komunikácie s konkrétnymi osobami. Toto povolenie umožňuje aplikáciám ukladať údaje o kontaktoch. Škodlivé aplikácie môžu zdieľať údaje o kontaktoch bez vášho vedomia."</string>
    <string name="permdesc_readContacts" product="tv" msgid="1839238344654834087">"Umožňuje aplikácii čítať údaje o kontaktoch uložených vo vašom televízore vrátane frekvencie volaní, odosielaní e-mailov alebo iných spôsobov komunikácie s konkrétnymi jednotlivcami. Toto povolenie umožňuje aplikáciám uložiť údaje o kontaktoch, ktoré môžu škodlivé aplikácie zdieľať bez vášho vedomia."</string>
    <string name="permdesc_readContacts" product="default" msgid="8440654152457300662">"Umožňuje aplikácii čítať údaje o kontaktoch uložených v telefóne vrátane informácií o frekvencii vašich telefonátov, odoslaných e-mailov alebo iných foriem komunikácie s konkrétnymi osobami. Toto povolenie umožňuje aplikáciám ukladať údaje o kontaktoch. Škodlivé aplikácie môžu zdieľať údaje o kontaktoch bez vášho vedomia."</string>
    <string name="permlab_writeContacts" msgid="5107492086416793544">"upraviť kontakty"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="897243932521953602">"Umožňuje aplikácii upraviť údaje o kontaktoch uložených v tablete vrátane informácií o frekvencii vašich telefonátov, odoslaných e-mailov alebo iných foriem komunikácie s konkrétnymi osobami. Toto povolenie umožňuje aplikáciám odstraňovať údaje o kontaktoch."</string>
    <string name="permdesc_writeContacts" product="tv" msgid="5438230957000018959">"Umožňuje aplikácii upravovať údaje o vašich kontaktoch uložených v televízore vrátane frekvencie volaní, odoslaní e-mailov a ďalších spôsobov komunikácie s konkrétnymi kontaktmi. Toto nastavenie umožňuje odstraňovať údaje o kontaktoch."</string>
    <string name="permdesc_writeContacts" product="default" msgid="589869224625163558">"Umožňuje aplikácii upraviť údaje o kontaktoch uložených v telefóne vrátane informácií o frekvencii vašich telefonátov, odoslaných e-mailov alebo iných foriem komunikácie s konkrétnymi osobami. Toto povolenie umožňuje aplikáciám odstraňovať údaje o kontaktoch."</string>
    <string name="permlab_readCallLog" msgid="3478133184624102739">"čítať denník hovorov"</string>
    <string name="permdesc_readCallLog" msgid="3204122446463552146">"Táto aplikácia môže čítať históriu vašich hovorov."</string>
    <string name="permlab_writeCallLog" msgid="8552045664743499354">"zapisovať do denníka hovorov"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="6661806062274119245">"Umožňuje aplikácii upravovať denník hovorov vo vašom tablete vrátane údajov o prichádzajúcich a odchádzajúcich hovoroch. Škodlivé aplikácie to môžu zneužiť na vymazanie alebo úpravu vášho denníka hovorov."</string>
    <string name="permdesc_writeCallLog" product="tv" msgid="4225034892248398019">"Umožňuje aplikácii upravovať denník hovorov vo vašom televízore vrátane údajov o prichádzajúcich a odchádzajúcich hovoroch. Škodlivé aplikácie to môžu zneužiť na vymazanie alebo úpravu vášho denníka hovorov."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="683941736352787842">"Umožňuje aplikácii upravovať denník hovorov vo vašom telefóne vrátane údajov o prichádzajúcich a odchádzajúcich hovoroch. Škodlivé aplikácie to môžu zneužiť na vymazanie alebo úpravu vášho denníka hovorov."</string>
    <string name="permlab_bodySensors" msgid="4683341291818520277">"prístup k telesným senzorom (ako sú snímače tepu)"</string>
    <string name="permdesc_bodySensors" product="default" msgid="4380015021754180431">"Umožňuje aplikácii získať prístup k údajom senzorov monitorujúcich vašu fyzickú kondíciu (napríklad pulz)."</string>
    <string name="permlab_readCalendar" msgid="6716116972752441641">"Čítanie udalostí kalendára a podrobností"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="4993979255403945892">"Táto aplikácia môže čítať všetky udalosti kalendára uložené vo vašom tablete a zdieľať alebo ukladať dáta kalendára."</string>
    <string name="permdesc_readCalendar" product="tv" msgid="8837931557573064315">"Táto aplikácia môže čítať všetky udalosti kalendára uložené vo vašom televízore a zdieľať alebo ukladať dáta kalendára."</string>
    <string name="permdesc_readCalendar" product="default" msgid="4373978642145196715">"Táto aplikácia môže čítať všetky udalosti kalendára uložené vo vašom telefóne a zdieľať alebo ukladať dáta kalendára."</string>
    <string name="permlab_writeCalendar" msgid="8438874755193825647">"pridať alebo upraviť udalosti v kalendári a odoslať e-mail hosťom bez vedomia vlastníka"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="1675270619903625982">"Táto aplikácia môže pridávať, odstraňovať alebo meniť udalosti kalendára vo vašom tablete. Táto aplikácia môže odosielať správy od vlastníkov kalendára alebo meniť udalosti bez upozornenia ich vlastníkov."</string>
    <string name="permdesc_writeCalendar" product="tv" msgid="9017809326268135866">"Táto aplikácia môže pridávať, odstraňovať alebo meniť udalosti kalendára vo vašom televízore. Táto aplikácia môže odosielať správy od vlastníkov kalendára alebo meniť udalosti bez upozornenia ich vlastníkov."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="7592791790516943173">"Táto aplikácia môže pridávať, odstraňovať alebo meniť udalosti kalendára vo vašom telefóne. Táto aplikácia môže odosielať správy od vlastníkov kalendára alebo meniť udalosti bez upozornenia ich vlastníkov."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"prístup k ďalším príkazom poskytovateľa polohy"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="6078307221056649927">"Umožňuje aplikácii pristupovať k ďalším príkazom poskytovateľa informácií o polohe. Aplikácii to môže umožniť zasahovať do činnosti systému GPS alebo iných zdrojov informácií o polohe."</string>
    <string name="permlab_accessFineLocation" msgid="251034415460950944">"prístup k presnej polohe (pomocou GPS a siete)"</string>
    <string name="permdesc_accessFineLocation" msgid="5821994817969957884">"Táto aplikácia môže získať údaje o vašej polohe na základe systému GPS alebo sieťových zdrojov, ako sú mobilné veže a siete Wi‑Fi. Na to, aby aplikácia mohla používať služby určovania polohy, musia byť tieto služby zapnuté a k dispozícii na telefóne. Môže to viesť k zvýšeniu spotreby batérie."</string>
    <string name="permlab_accessCoarseLocation" msgid="7715277613928539434">"prístup k približnej polohe (pomocou siete)"</string>
    <string name="permdesc_accessCoarseLocation" product="tablet" msgid="3373266766487862426">"Táto aplikácia môže získať údaje o vašej polohe na základe sieťových zdrojov, ako sú mobilné veže a siete Wi‑Fi. Na to, aby aplikácia mohla používať služby určovania polohy, musia byť tieto služby zapnuté a k dispozícii na tablete."</string>
    <string name="permdesc_accessCoarseLocation" product="tv" msgid="1884022719818788511">"Táto aplikácia môže získať údaje o vašej polohe na základe sieťových zdrojov, ako sú mobilné veže a siete Wi‑Fi. Na to, aby aplikácia mohla používať služby určovania polohy, musia byť tieto služby zapnuté a k dispozícii na televízore."</string>
    <string name="permdesc_accessCoarseLocation" product="default" msgid="7788009094906196995">"Táto aplikácia môže získať údaje o vašej polohe na základe sieťových zdrojov, ako sú mobilné veže a siete Wi‑Fi. Na to, aby aplikácia mohla používať služby určovania polohy, musia byť tieto služby zapnuté a k dispozícii na telefóne."</string>
    <string name="permlab_modifyAudioSettings" msgid="6095859937069146086">"meniť nastavenia zvuku"</string>
    <string name="permdesc_modifyAudioSettings" msgid="3522565366806248517">"Umožňuje aplikácii upraviť globálne nastavenia zvuku, ako je hlasitosť, alebo určiť, z ktorého reproduktora bude zvuk vychádzať."</string>
    <string name="permlab_recordAudio" msgid="3876049771427466323">"nahrávať zvuk"</string>
    <string name="permdesc_recordAudio" msgid="4245930455135321433">"Táto aplikácia môže kedykoľvek zaznamenávať zvuk pomocou mikrofónu."</string>
    <string name="permlab_sim_communication" msgid="2935852302216852065">"posielanie príkazov do SIM karty"</string>
    <string name="permdesc_sim_communication" msgid="5725159654279639498">"Umožňuje aplikácii odosielať príkazy na SIM kartu. Toto je veľmi nebezpečné povolenie."</string>
    <string name="permlab_camera" msgid="3616391919559751192">"fotiť a nakrúcať videá"</string>
    <string name="permdesc_camera" msgid="5392231870049240670">"Táto aplikácia môže kedykoľvek fotografovať a zaznamenávať videá pomocou fotoaparátu."</string>
    <string name="permlab_vibrate" msgid="7696427026057705834">"ovládať vibrovanie"</string>
    <string name="permdesc_vibrate" msgid="6284989245902300945">"Umožňuje aplikácii ovládať vibrácie."</string>
    <string name="permlab_callPhone" msgid="3925836347681847954">"priamo volať na telefónne čísla"</string>
    <string name="permdesc_callPhone" msgid="3740797576113760827">"Umožňuje aplikácii volať telefónne čísla bez vášho zásahu. V dôsledku toho sa môžu účtovať neočakávané poplatky alebo sa môžu uskutočniť neočakávané hovory. Toto povolenie neumožňuje aplikácii volať na čísla tiesňového volania."</string>
    <string name="permlab_accessImsCallService" msgid="3574943847181793918">"prístup k službe volania IMS"</string>
    <string name="permdesc_accessImsCallService" msgid="8992884015198298775">"Umožňuje aplikácii používať službu okamžitých správ (IMS) na volanie bez intervencie používateľa."</string>
    <string name="permlab_readPhoneState" msgid="9178228524507610486">"čítať stav a identitu telefónu"</string>
    <string name="permdesc_readPhoneState" msgid="1639212771826125528">"Umožňuje aplikácii pristupovať k telefónnym funkciám zariadenia. Aplikácia s týmto povolením môže určiť telefónne číslo a ID zariadenia, či práve prebieha hovor, a vzdialené číslo, s ktorým je prostredníctvom hovoru nadviazané spojenie."</string>
    <string name="permlab_manageOwnCalls" msgid="1503034913274622244">"presmerovanie hovorov cez systém"</string>
    <string name="permdesc_manageOwnCalls" msgid="6552974537554717418">"Umožňuje aplikácii presmerovať hovory cez systém na účely zlepšenia kvality hovorov."</string>
    <string name="permlab_readPhoneNumbers" msgid="6108163940932852440">"čítanie telefónnych čísel"</string>
    <string name="permdesc_readPhoneNumbers" msgid="8559488833662272354">"Umožňuje aplikácii pristupovať k telefónnym číslam zariadenia."</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1531731435011495015">"zabránenie prechodu tabletu do režimu spánku"</string>
    <string name="permlab_wakeLock" product="tv" msgid="2601193288949154131">"zabránenie televízoru v prechode do režimu spánku"</string>
    <string name="permlab_wakeLock" product="default" msgid="573480187941496130">"deaktivovať režim spánku"</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="7311319824400447868">"Umožňuje aplikácii zabrániť prechodu tabletu do režimu spánku."</string>
    <string name="permdesc_wakeLock" product="tv" msgid="3208534859208996974">"Umožňuje aplikácii zabrániť televízoru v prechode do režimu spánku."</string>
    <string name="permdesc_wakeLock" product="default" msgid="8559100677372928754">"Umožňuje aplikácii zabrániť prechodu telefónu do režimu spánku."</string>
    <string name="permlab_transmitIr" msgid="7545858504238530105">"infračervený prenos"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5358308854306529170">"Umožňuje aplikácii používať infračervený vysielač tabletu."</string>
    <string name="permdesc_transmitIr" product="tv" msgid="3926790828514867101">"Umožňuje aplikácii použiť infračervený vysielač televízora."</string>
    <string name="permdesc_transmitIr" product="default" msgid="7957763745020300725">"Umožňuje aplikácii používať infračervený vysielač telefónu."</string>
    <string name="permlab_setWallpaper" msgid="6627192333373465143">"nastaviť tapetu"</string>
    <string name="permdesc_setWallpaper" msgid="7373447920977624745">"Umožňuje aplikácii nastaviť tapetu systému."</string>
    <string name="permlab_setWallpaperHints" msgid="3278608165977736538">"upraviť veľkosť tapety"</string>
    <string name="permdesc_setWallpaperHints" msgid="8235784384223730091">"Umožňuje aplikácii nastaviť tipy pre veľkosť tapety systému."</string>
    <string name="permlab_setTimeZone" msgid="2945079801013077340">"nastavenie časového pásma"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1676983712315827645">"Umožňuje aplikácii zmeniť časové pásmo tabletu."</string>
    <string name="permdesc_setTimeZone" product="tv" msgid="888864653946175955">"Umožňuje aplikácii zmeniť časové pásmo televízora."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4499943488436633398">"Umožňuje aplikácii zmeniť časové pásmo telefónu."</string>
    <string name="permlab_getAccounts" msgid="1086795467760122114">"nájsť účty na zariadení"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="2741496534769660027">"Umožňuje aplikácii získať zoznam účtov v tablete. Môžu sem patriť akékoľvek účty vytvorené aplikáciami, ktoré ste nainštalovali."</string>
    <string name="permdesc_getAccounts" product="tv" msgid="4190633395633907543">"Umožňuje aplikácii získať zoznam účtov z televízora. Môžu sem patriť ľubovoľné účty vytvorené aplikáciami, ktoré ste si nainštalovali."</string>
    <string name="permdesc_getAccounts" product="default" msgid="3448316822451807382">"Umožňuje aplikácii získať zoznam účtov v telefóne. Môžu sem patriť akékoľvek účty vytvorené aplikáciami, ktoré ste nainštalovali."</string>
    <string name="permlab_accessNetworkState" msgid="4951027964348974773">"zobraziť sieťové pripojenia"</string>
    <string name="permdesc_accessNetworkState" msgid="8318964424675960975">"Umožňuje aplikácii zobraziť informácie o sieťových pripojeniach, ako napríklad o tom, ktoré siete sú k dispozícii a ktoré sú pripojené."</string>
    <string name="permlab_createNetworkSockets" msgid="7934516631384168107">"úplný prístup k sieti"</string>
    <string name="permdesc_createNetworkSockets" msgid="3403062187779724185">"Umožňuje aplikácii vytvárať sokety siete a používať vlastné protokoly siete. Toto povolenie sa pri odosielaní údajov na internet nevyžaduje, pretože prostriedky na odosielanie údajov na internet poskytujú prehliadač a iné aplikácie."</string>
    <string name="permlab_changeNetworkState" msgid="958884291454327309">"zmena sieťového pripojenia"</string>
    <string name="permdesc_changeNetworkState" msgid="6789123912476416214">"Umožňuje aplikácii zmeniť stav sieťového pripojenia zdieľaného pomocou tetheringu."</string>
    <string name="permlab_changeTetherState" msgid="5952584964373017960">"zmeniť zdieľané dátové pripojenie"</string>
    <string name="permdesc_changeTetherState" msgid="1524441344412319780">"Umožňuje aplikácii zmeniť stav sieťového pripojenia zdieľaného pomocou tetheringu."</string>
    <string name="permlab_accessWifiState" msgid="5202012949247040011">"zobraziť pripojenia Wi‑Fi"</string>
    <string name="permdesc_accessWifiState" msgid="5002798077387803726">"Umožňuje aplikácii zobraziť informácie o sieťach Wi‑Fi. Napríklad o tom, či je sieť Wi‑Fi povolená alebo názvy pripojených zariadení Wi‑Fi."</string>
    <string name="permlab_changeWifiState" msgid="6550641188749128035">"pripojiť a odpojiť od siete Wi‑Fi"</string>
    <string name="permdesc_changeWifiState" msgid="7137950297386127533">"Umožňuje aplikácii pripojiť sa na prístupové body siete Wi‑Fi, odpojiť sa od nich a meniť konfiguráciu zariadení pre siete Wi‑Fi."</string>
    <string name="permlab_changeWifiMulticastState" msgid="1368253871483254784">"povoliť príjem Wi‑Fi Multicast"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="7969774021256336548">"Umožňuje aplikácii prijímať pakety odoslané na všetky zariadenia v sieti Wi‑Fi pomocou viacsmerových adries, nielen pomocou vášho tabletu. Spotrebuje viac energie ako režim bez viacsmerového vysielania."</string>
    <string name="permdesc_changeWifiMulticastState" product="tv" msgid="9031975661145014160">"Umožňuje aplikácii prijímať pakety odosielané na všetky zariadenia v sieti Wi‑Fi pomocou viacsmerových adries (a nie iba do vášho televízora). Spotrebúva viac energie ako režim bez viacsmerového vysielania."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="6851949706025349926">"Umožňuje aplikácii prijímať pakety odoslané na všetky zariadenia v sieti Wi‑Fi pomocou viacsmerových adries, nielen pomocou vášho telefónu. Spotrebuje viac energie ako režim bez viacsmerového vysielania."</string>
    <string name="permlab_bluetoothAdmin" msgid="6006967373935926659">"pristupovať k nastaveniam Bluetooth"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="6921177471748882137">"Umožňuje aplikácii konfigurovať miestny tablet s rozhraním Bluetooth a vyhľadávať a spárovať vzdialené zariadenia."</string>
    <string name="permdesc_bluetoothAdmin" product="tv" msgid="3373125682645601429">"Umožňuje aplikácii konfigurovať miestny televízor s rozhraním Bluetooth, objavovať vzdialené zariadenia a párovať sa s nimi."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="8931682159331542137">"Umožňuje aplikácii konfigurovať miestny telefón s rozhraním Bluetooth, vyhľadávať a spárovať vzdialené zariadenia."</string>
    <string name="permlab_accessWimaxState" msgid="4195907010610205703">"pripojiť a odpojiť od WiMAX"</string>
    <string name="permdesc_accessWimaxState" msgid="6360102877261978887">"Umožňuje aplikácii určiť, či je povolený štandard WiMAX, a tiež informácie o všetkých pripojených sieťach WiMAX."</string>
    <string name="permlab_changeWimaxState" msgid="340465839241528618">"zmeniť stav WiMAX"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="3156456504084201805">"Umožňuje aplikácii pripojiť tablet k sieťam WiMAX a odpojiť ho od nich."</string>
    <string name="permdesc_changeWimaxState" product="tv" msgid="6022307083934827718">"Umožňuje aplikácii pripojiť televízor k sieťam WiMAX a odpojiť ho z nich."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="697025043004923798">"Umožňuje aplikácii pripojiť telefón k sieťam WiMAX a odpojiť ho od nich."</string>
    <string name="permlab_bluetooth" msgid="6127769336339276828">"párovať so zariadeniami Bluetooth"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3480722181852438628">"Umožňuje aplikácii zobraziť informácie o konfigurácii Bluetooth na tablete. Taktiež jej umožňuje nadväzovať a akceptovať spojenia so spárovanými zariadeniami."</string>
    <string name="permdesc_bluetooth" product="tv" msgid="3974124940101104206">"Umožňuje aplikácii zobrazovať konfiguráciu rozhrania Bluetooth v televízore, uskutočňovať pripojenia so spárovanými zariadeniami aj prijímať ich."</string>
    <string name="permdesc_bluetooth" product="default" msgid="3207106324452312739">"Umožňuje aplikácii zobraziť informácie o konfigurácii Bluetooth na telefóne. Taktiež jej umožňuje nadväzovať a akceptovať spojenia so spárovanými zariadeniami."</string>
    <string name="permlab_nfc" msgid="4423351274757876953">"ovládať technológiu NFC"</string>
    <string name="permdesc_nfc" msgid="7120611819401789907">"Umožňuje aplikácii komunikovať so značkami, kartami a čítačkami s podporou technológie NFC."</string>
    <string name="permlab_disableKeyguard" msgid="3598496301486439258">"deaktivácia zámky obrazovky"</string>
    <string name="permdesc_disableKeyguard" msgid="6034203065077122992">"Umožňuje aplikácii zakázať uzamknutie klávesnice a akékoľvek súvisiace zabezpečenie heslom. Príkladom je zakázanie uzamknutia klávesnice pri prichádzajúcom telefonickom hovore a jeho opätovné povolenie po skončení hovoru."</string>
    <string name="permlab_manageFingerprint" msgid="5640858826254575638">"spravovať hardvér na snímanie odtlačkov prstov"</string>
    <string name="permdesc_manageFingerprint" msgid="178208705828055464">"Umožňuje aplikácii zavolať metódy, ktoré pridávajú a odstraňujú vzory odtlačkov prstov."</string>
    <string name="permlab_useFingerprint" msgid="3150478619915124905">"použiť hardvér na snímanie odtlačkov prstov"</string>
    <string name="permdesc_useFingerprint" msgid="9165097460730684114">"Umožňuje aplikácii používať na overenie totožnosti hardvér na snímanie odtlačkov prstov."</string>
    <string name="fingerprint_acquired_partial" msgid="735082772341716043">"Podarilo sa rozpoznať iba časť odtlačku prsta. Skúste to znova."</string>
    <string name="fingerprint_acquired_insufficient" msgid="4596546021310923214">"Odtlačok prsta sa nepodarilo spracovať. Skúste to znova."</string>
    <string name="fingerprint_acquired_imager_dirty" msgid="1087209702421076105">"Snímač odtlačkov je špinavý. Vyčistite ho a skúste to znova."</string>
    <string name="fingerprint_acquired_too_fast" msgid="6470642383109155969">"Pohli ste prstom príliš rýchlo. Skúste to znova."</string>
    <string name="fingerprint_acquired_too_slow" msgid="59250885689661653">"Pohli ste prstom príliš pomaly. Skúste to znova."</string>
  <string-array name="fingerprint_acquired_vendor">
  </string-array>
    <string name="fingerprint_error_hw_not_available" msgid="7955921658939936596">"Hardvér na snímanie odtlačku prsta nie je k dispozícii"</string>
    <string name="fingerprint_error_no_space" msgid="1055819001126053318">"Odtlačok prsta nie je možné uložiť. Odstráňte existujúci odtlačok."</string>
    <string name="fingerprint_error_timeout" msgid="3927186043737732875">"Časový limit rozpoznania odtlačku vypršal. Skúste to znova."</string>
    <string name="fingerprint_error_canceled" msgid="4402024612660774395">"Operácia týkajúca sa odtlačku prsta bola zrušená"</string>
    <string name="fingerprint_error_lockout" msgid="5536934748136933450">"Príliš veľa pokusov. Skúste to znova neskôr."</string>
    <string name="fingerprint_error_lockout_permanent" msgid="5033251797919508137">"Príliš veľa pokusov. Senzor odtlačkov prstov bol deaktivovaný."</string>
    <string name="fingerprint_error_unable_to_process" msgid="6107816084103552441">"Skúste to znova"</string>
    <string name="fingerprint_name_template" msgid="5870957565512716938">"Prst: <xliff:g id="FINGERID">%d</xliff:g>"</string>
  <string-array name="fingerprint_error_vendor">
  </string-array>
    <string name="fingerprint_icon_content_description" msgid="2340202869968465936">"Ikona odtlačku prsta"</string>
    <string name="permlab_readSyncSettings" msgid="6201810008230503052">"čítať nastavenia synchronizácie"</string>
    <string name="permdesc_readSyncSettings" msgid="2706745674569678644">"Umožňuje aplikácii čítať nastavenia synchronizácie v účte. Môže napríklad určiť, či je s účtom synchronizovaná aplikácia Ľudia."</string>
    <string name="permlab_writeSyncSettings" msgid="5408694875793945314">"zapnúť alebo vypnúť synchronizáciu"</string>
    <string name="permdesc_writeSyncSettings" msgid="8956262591306369868">"Umožňuje aplikácii upraviť nastavenia synchronizácie v účte. Pomocou tohto povolenia je možné napríklad povoliť synchronizáciu aplikácie Ľudia s účtom."</string>
    <string name="permlab_readSyncStats" msgid="7396577451360202448">"čítať štatistické údaje o synchronizácii"</string>
    <string name="permdesc_readSyncStats" msgid="1510143761757606156">"Umožňuje aplikácii čítať štatistické informácie o synchronizácii v účte vrátane histórie uskutočnených synchronizácií a informácií o množstve synchronizovaných údajov."</string>
    <string name="permlab_sdcardRead" product="nosdcard" msgid="367275095159405468">"čítať obsah úložiska USB"</string>
    <string name="permlab_sdcardRead" product="default" msgid="2188156462934977940">"čítať obsah SD karty"</string>
    <string name="permdesc_sdcardRead" product="nosdcard" msgid="3446988712598386079">"Povoľuje ap. čítať obsah USB."</string>
    <string name="permdesc_sdcardRead" product="default" msgid="2607362473654975411">"Povoľuje aplikácii čítať obsah SD karty."</string>
    <string name="permlab_sdcardWrite" product="nosdcard" msgid="8485979062254666748">"upraviť alebo odstrániť obsah v úložisku USB"</string>
    <string name="permlab_sdcardWrite" product="default" msgid="8805693630050458763">"úprava alebo odstránenie obsahu na SD karte"</string>
    <string name="permdesc_sdcardWrite" product="nosdcard" msgid="6175406299445710888">"Umožňuje aplikácii zapisovať do úložiska USB."</string>
    <string name="permdesc_sdcardWrite" product="default" msgid="4337417790936632090">"Umožňuje aplikácii zápis na SD kartu."</string>
    <string name="permlab_use_sip" msgid="2052499390128979920">"uskutočňovanie/príjem hovorov SIP"</string>
    <string name="permdesc_use_sip" msgid="2297804849860225257">"Umožňuje aplikácii uskutočňovať a prijímať hovory SIP."</string>
    <string name="permlab_register_sim_subscription" msgid="3166535485877549177">"registrácia nových pripojení telekomunikačnej siete SIM"</string>
    <string name="permdesc_register_sim_subscription" msgid="2138909035926222911">"Povoľuje aplikácii registrovať nové pripojenia telekomunikačnej siete SIM."</string>
    <string name="permlab_register_call_provider" msgid="108102120289029841">"registrácia nových pripojení telekomunikačnej siete"</string>
    <string name="permdesc_register_call_provider" msgid="7034310263521081388">"Povoľuje aplikácii registrovať nové pripojenia telekomunikačnej siete."</string>
    <string name="permlab_connection_manager" msgid="1116193254522105375">"správa pripojení telefonických sietí"</string>
    <string name="permdesc_connection_manager" msgid="5925480810356483565">"Povoľuje aplikácii spravovať pripojenia telekomunikačnej siete."</string>
    <string name="permlab_bind_incall_service" msgid="6773648341975287125">"interakcia s obrazovkou hovoru"</string>
    <string name="permdesc_bind_incall_service" msgid="8343471381323215005">"Umožňuje aplikácii ovládať, kedy a ako sa používateľovi zobrazí obrazovka hovoru."</string>
    <string name="permlab_bind_connection_service" msgid="3557341439297014940">"komunikovať s telefonickými službami"</string>
    <string name="permdesc_bind_connection_service" msgid="4008754499822478114">"Umožňuje aplikácii komunikovať s telefonickými službami a uskutočňovať a prijímať hovory."</string>
    <string name="permlab_control_incall_experience" msgid="9061024437607777619">"zobrazenie používateľského prostredia počas hovoru"</string>
    <string name="permdesc_control_incall_experience" msgid="915159066039828124">"Umožňuje aplikácii zobraziť používateľské prostredie počas hovoru."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="7862593283611493232">"čítať históriu používania siete"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="7689060749819126472">"Umožňuje aplikácii čítať históriu používania siete pre určité siete a aplikácie."</string>
    <string name="permlab_manageNetworkPolicy" msgid="2562053592339859990">"spravovať pravidlá siete"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="7537586771559370668">"Umožňuje aplikácii spravovať pravidlá siete a definovať pravidlá pre konkrétnu aplikáciu."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="5088217309088729650">"zmeniť kontrolu používania siete"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5443412866746198123">"Umožňuje aplikácii upraviť používanie siete jednotlivými aplikáciami. Bežné aplikácie toto nastavenie nepoužívajú."</string>
    <string name="permlab_accessNotifications" msgid="7673416487873432268">"prístup k upozorneniam"</string>
    <string name="permdesc_accessNotifications" msgid="458457742683431387">"Umožňuje aplikácii načítať, zobrazovať a mazať upozornenia vrátane tých, ktoré boli uverejnené inými aplikáciami."</string>
    <string name="permlab_bindNotificationListenerService" msgid="7057764742211656654">"naviazanie sa na službu na počúvanie upozornení"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="985697918576902986">"Umožňuje držiteľovi naviazať sa na najvyššiu úroveň služby na počúvanie upozornení. Bežné aplikácie by toto nastavenie nemali nikdy požadovať."</string>
    <string name="permlab_bindConditionProviderService" msgid="1180107672332704641">"viazanie na službu poskytovateľa podmienky"</string>
    <string name="permdesc_bindConditionProviderService" msgid="1680513931165058425">"Umožňuje držiteľovi viazať sa na najvyššiu úroveň rozhrania služby poskytovateľa podmienky. Bežné aplikácie by toto povolenie nemali nikdy potrebovať."</string>
    <string name="permlab_bindDreamService" msgid="4153646965978563462">"viazať sa so službou Dream service"</string>
    <string name="permdesc_bindDreamService" msgid="7325825272223347863">"Umožňuje držiteľovi viazať sa na najvyššiu úroveň rozhrania služby Dream service. Bežné aplikácie by toto povolenie nemali nikdy potrebovať."</string>
    <string name="permlab_invokeCarrierSetup" msgid="3699600833975117478">"vyvolanie aplikácie pre konfiguráciu poskytnutú operátorom"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4159549152529111920">"Umožňuje držiteľovi vyvolať aplikáciu pre konfiguráciu poskytnutú operátorom. Bežné aplikácie by toto povolenie nemali nikdy potrebovať."</string>
    <string name="permlab_accessNetworkConditions" msgid="8206077447838909516">"zachytávať informácie o stave siete"</string>
    <string name="permdesc_accessNetworkConditions" msgid="6899102075825272211">"Umožňuje aplikácii zachytávať informácie o stave siete. Bežné aplikácie by toto povolenie nemali nikdy potrebovať."</string>
    <string name="permlab_setInputCalibration" msgid="4902620118878467615">"zmeniť kalibráciu vstupného zariadenia"</string>
    <string name="permdesc_setInputCalibration" msgid="4527511047549456929">"Umožňuje aplikácii upraviť parametre kalibrácie dotykovej obrazovky. Bežné aplikácie by toto povolenie nemali nikdy potrebovať."</string>
    <string name="permlab_accessDrmCertificates" msgid="7436886640723203615">"prístup k certifikátom DRM"</string>
    <string name="permdesc_accessDrmCertificates" msgid="8073288354426159089">"Umožňuje aplikácii vydávať a používať certifikáty DRM. Bežné aplikácie by toto povolenie nemali nikdy potrebovať."</string>
    <string name="permlab_handoverStatus" msgid="7820353257219300883">"príjem stavu prenosov Android Beam"</string>
    <string name="permdesc_handoverStatus" msgid="4788144087245714948">"Povoľuje tejto aplikácii prijímať informácie o aktuálnych prenosoch funkcie Android Beam"</string>
    <string name="permlab_removeDrmCertificates" msgid="7044888287209892751">"odstránenie certifikátov DRM"</string>
    <string name="permdesc_removeDrmCertificates" msgid="7272999075113400993">"Umožňuje aplikácii odstraňovať certifikáty DRM. Bežné aplikácie by toto povolenie nemali nikdy potrebovať."</string>
    <string name="permlab_bindCarrierMessagingService" msgid="1490229371796969158">"viazať sa na službu na odosielanie správ SMS a MMS operátora"</string>
    <string name="permdesc_bindCarrierMessagingService" msgid="2762882888502113944">"Umožňuje držiteľovi viazať sa na najvyššiu úroveň rozhrania služby na odosielanie správ SMS a MMS operátora. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_bindCarrierServices" msgid="3233108656245526783">"naviazať sa na služby operátora"</string>
    <string name="permdesc_bindCarrierServices" msgid="1391552602551084192">"Umožňuje držiteľovi povolenia naviazať sa na služby operátora. Bežné aplikácie by toto povolenie nemali nikdy nepotrebovať."</string>
    <string name="permlab_access_notification_policy" msgid="4247510821662059671">"prístup k nastaveniu Nerušiť"</string>
    <string name="permdesc_access_notification_policy" msgid="3296832375218749580">"Umožňuje aplikácii čítať a zapisovať konfiguráciu nastavenia Nerušiť."</string>
    <string name="policylab_limitPassword" msgid="4497420728857585791">"Nastaviť pravidlá pre heslo"</string>
    <string name="policydesc_limitPassword" msgid="2502021457917874968">"Nastavte dĺžku hesiel na odomknutie obrazovky aj kódov PIN a v nich používané znaky."</string>
    <string name="policylab_watchLogin" msgid="5091404125971980158">"Sledovanie pokusov o odomknutie obrazovky"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="3215729294215070072">"Sledovať počet nesprávnych hesiel zadaných pri odomykaní obrazovky a zamknúť tablet alebo vymazať všetky údaje tabletu v prípade príliš veľkého počtu neplatných pokusov o zadanie hesla."</string>
    <string name="policydesc_watchLogin" product="TV" msgid="2707817988309890256">"Sledujte počet nesprávnych hesiel zadaných pri odomykaní obrazovky a v prípade, že ich je zadaných príliš mnoho, uzamknite televízor alebo vymažte všetky údaje v ňom."</string>
    <string name="policydesc_watchLogin" product="default" msgid="5712323091846761073">"Sledovať počet nesprávnych hesiel zadaných pri odomykaní obrazovky a zamknúť telefón alebo vymazať všetky údaje v telefóne v prípade príliš veľkého počtu neplatných pokusov o zadanie hesla."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="tablet" msgid="4280246270601044505">"Sledujte počet nesprávnych hesiel zadaných pri odomykaní obrazovky a v prípade, že ich je zadaných príliš mnoho, uzamknite tablet alebo vymažte všetky údaje tohto používateľa."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="TV" msgid="3484832653564483250">"Sledujte počet nesprávnych hesiel zadaných pri odomykaní obrazovky a v prípade, že ich je zadaných príliš mnoho, uzamknite televízor alebo vymažte všetky údaje tohto používateľa."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="default" msgid="2185480427217127147">"Sledujte počet nesprávnych hesiel zadaných pri odomykaní obrazovky a v prípade, že ich je zadaných príliš mnoho, uzamknite telefón alebo vymažte všetky údaje tohto používateľa."</string>
    <string name="policylab_resetPassword" msgid="4934707632423915395">"Zmeniť zámku obrazovky"</string>
    <string name="policydesc_resetPassword" msgid="1278323891710619128">"Zmeniť zámku obrazovky."</string>
    <string name="policylab_forceLock" msgid="2274085384704248431">"Uzamknúť obrazovku"</string>
    <string name="policydesc_forceLock" msgid="1141797588403827138">"Ovládať, ako a kedy sa obrazovka uzamkne."</string>
    <string name="policylab_wipeData" msgid="3910545446758639713">"Vymazať všetky dáta"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="4306184096067756876">"Bez predchádzajúceho upozornenia vymazať všetky dáta obnovením výrobných nastavení tabletu."</string>
    <string name="policydesc_wipeData" product="tv" msgid="5816221315214527028">"Bez predchádzajúceho upozornenia vymazať všetky dáta televízora obnovením jeho výrobných nastavení."</string>
    <string name="policydesc_wipeData" product="default" msgid="5096895604574188391">"Bez predchádzajúceho upozornenia vymazať všetky dáta obnovením výrobných nastavení telefónu."</string>
    <string name="policylab_wipeData_secondaryUser" msgid="8362863289455531813">"Vymazať údaje používateľa"</string>
    <string name="policydesc_wipeData_secondaryUser" product="tablet" msgid="6336255514635308054">"Vymažte bez upozornenia údaje tohto používateľa na tomto tablete."</string>
    <string name="policydesc_wipeData_secondaryUser" product="tv" msgid="2086473496848351810">"Vymažte bez upozornenia údaje tohto používateľa na tomto televízore."</string>
    <string name="policydesc_wipeData_secondaryUser" product="default" msgid="6787904546711590238">"Vymažte bez upozornenia údaje tohto používateľa na tomto telefóne."</string>
    <string name="policylab_setGlobalProxy" msgid="2784828293747791446">"Nastaviť globálny server proxy zariadenia"</string>
    <string name="policydesc_setGlobalProxy" msgid="8459859731153370499">"Vyberte globálny proxy server, ktorý sa bude používať po aktivácii pravidiel. Nastaviť ho môže iba vlastník zariadenia."</string>
    <string name="policylab_expirePassword" msgid="5610055012328825874">"Nastaviť dátum vypršania platnosti zámky obrazovky"</string>
    <string name="policydesc_expirePassword" msgid="5367525762204416046">"Nastavte, ako často sa musí zmeniť heslo na uzamknutie obrazovky, kód PIN alebo vzor."</string>
    <string name="policylab_encryptedStorage" msgid="8901326199909132915">"Nastaviť šifrovanie úložiska"</string>
    <string name="policydesc_encryptedStorage" msgid="2637732115325316992">"Vyžadovať šifrovanie uložených údajov aplikácií."</string>
    <string name="policylab_disableCamera" msgid="6395301023152297826">"Zakázať fotoaparáty"</string>
    <string name="policydesc_disableCamera" msgid="2306349042834754597">"Zakázať používanie všetkých fotoaparátov zariadenia."</string>
    <string name="policylab_disableKeyguardFeatures" msgid="8552277871075367771">"Deaktivácia niektorých funkcií zámky obrazovky"</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="2044755691354158439">"Zabráňte používaniu niektorých funkcií zámky obrazovky."</string>
  <string-array name="phoneTypes">
    <item msgid="8901098336658710359">"Domov"</item>
    <item msgid="869923650527136615">"Mobil"</item>
    <item msgid="7897544654242874543">"Práca"</item>
    <item msgid="1103601433382158155">"Fax práca"</item>
    <item msgid="1735177144948329370">"Fax domov"</item>
    <item msgid="603878674477207394">"Pager"</item>
    <item msgid="1650824275177931637">"Iné"</item>
    <item msgid="9192514806975898961">"Vlastné"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="8073994352956129127">"Domov"</item>
    <item msgid="7084237356602625604">"Práca"</item>
    <item msgid="1112044410659011023">"Iné"</item>
    <item msgid="2374913952870110618">"Vlastné"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="6880257626740047286">"Domov"</item>
    <item msgid="5629153956045109251">"Práca"</item>
    <item msgid="4966604264500343469">"Iné"</item>
    <item msgid="4932682847595299369">"Vlastné"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="1738585194601476694">"Domov"</item>
    <item msgid="1359644565647383708">"Práca"</item>
    <item msgid="7868549401053615677">"Iné"</item>
    <item msgid="3145118944639869809">"Vlastné"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="7546335612189115615">"Práca"</item>
    <item msgid="4378074129049520373">"Iné"</item>
    <item msgid="3455047468583965104">"Vlastné"</item>
  </string-array>
  <string-array name="imProtocols">
    <item msgid="8595261363518459565">"AIM"</item>
    <item msgid="7390473628275490700">"Windows Live"</item>
    <item msgid="7882877134931458217">"Yahoo"</item>
    <item msgid="5035376313200585242">"Skype"</item>
    <item msgid="7532363178459444943">"QQ"</item>
    <item msgid="3713441034299660749">"Google Talk"</item>
    <item msgid="2506857312718630823">"ICQ"</item>
    <item msgid="1648797903785279353">"Jabber"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="1644738059053355820">"Vlastné"</string>
    <string name="phoneTypeHome" msgid="2570923463033985887">"Domov"</string>
    <string name="phoneTypeMobile" msgid="6501463557754751037">"Mobil"</string>
    <string name="phoneTypeWork" msgid="8863939667059911633">"Práca"</string>
    <string name="phoneTypeFaxWork" msgid="3517792160008890912">"Fax práca"</string>
    <string name="phoneTypeFaxHome" msgid="2067265972322971467">"Fax domov"</string>
    <string name="phoneTypePager" msgid="7582359955394921732">"Pager"</string>
    <string name="phoneTypeOther" msgid="1544425847868765990">"Iné"</string>
    <string name="phoneTypeCallback" msgid="2712175203065678206">"Spätné volanie"</string>
    <string name="phoneTypeCar" msgid="8738360689616716982">"Telefón v aute"</string>
    <string name="phoneTypeCompanyMain" msgid="540434356461478916">"Hlavné firemné"</string>
    <string name="phoneTypeIsdn" msgid="8022453193171370337">"ISDN"</string>
    <string name="phoneTypeMain" msgid="6766137010628326916">"Hlavné"</string>
    <string name="phoneTypeOtherFax" msgid="8587657145072446565">"Iný fax"</string>
    <string name="phoneTypeRadio" msgid="4093738079908667513">"Rádiotelefón"</string>
    <string name="phoneTypeTelex" msgid="3367879952476250512">"Telex"</string>
    <string name="phoneTypeTtyTdd" msgid="8606514378585000044">"Textový telefón"</string>
    <string name="phoneTypeWorkMobile" msgid="1311426989184065709">"Pracovný mobil"</string>
    <string name="phoneTypeWorkPager" msgid="649938731231157056">"Pracovný pager"</string>
    <string name="phoneTypeAssistant" msgid="5596772636128562884">"Asistent"</string>
    <string name="phoneTypeMms" msgid="7254492275502768992">"MMS"</string>
    <string name="eventTypeCustom" msgid="7837586198458073404">"Vlastné"</string>
    <string name="eventTypeBirthday" msgid="2813379844211390740">"Narodeniny"</string>
    <string name="eventTypeAnniversary" msgid="3876779744518284000">"Výročie"</string>
    <string name="eventTypeOther" msgid="7388178939010143077">"Iné"</string>
    <string name="emailTypeCustom" msgid="8525960257804213846">"Vlastné"</string>
    <string name="emailTypeHome" msgid="449227236140433919">"Domov"</string>
    <string name="emailTypeWork" msgid="3548058059601149973">"Práca"</string>
    <string name="emailTypeOther" msgid="2923008695272639549">"Iné"</string>
    <string name="emailTypeMobile" msgid="119919005321166205">"Mobil"</string>
    <string name="postalTypeCustom" msgid="8903206903060479902">"Vlastné"</string>
    <string name="postalTypeHome" msgid="8165756977184483097">"Domov"</string>
    <string name="postalTypeWork" msgid="5268172772387694495">"Práca"</string>
    <string name="postalTypeOther" msgid="2726111966623584341">"Iné"</string>
    <string name="imTypeCustom" msgid="2074028755527826046">"Vlastné"</string>
    <string name="imTypeHome" msgid="6241181032954263892">"Domov"</string>
    <string name="imTypeWork" msgid="1371489290242433090">"Práca"</string>
    <string name="imTypeOther" msgid="5377007495735915478">"Iné"</string>
    <string name="imProtocolCustom" msgid="6919453836618749992">"Vlastné"</string>
    <string name="imProtocolAim" msgid="7050360612368383417">"AIM"</string>
    <string name="imProtocolMsn" msgid="144556545420769442">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="8271439408469021273">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="9019296744622832951">"Skype"</string>
    <string name="imProtocolQq" msgid="8887484379494111884">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="493902321140277304">"Hangouts"</string>
    <string name="imProtocolIcq" msgid="1574870433606517315">"ICQ"</string>
    <string name="imProtocolJabber" msgid="2279917630875771722">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="8287625655986827971">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="29268870505363872">"Práca"</string>
    <string name="orgTypeOther" msgid="3951781131570124082">"Iné"</string>
    <string name="orgTypeCustom" msgid="225523415372088322">"Vlastné"</string>
    <string name="relationTypeCustom" msgid="3542403679827297300">"Vlastné"</string>
    <string name="relationTypeAssistant" msgid="6274334825195379076">"Asistent"</string>
    <string name="relationTypeBrother" msgid="8757913506784067713">"Brat"</string>
    <string name="relationTypeChild" msgid="1890746277276881626">"Dieťa"</string>
    <string name="relationTypeDomesticPartner" msgid="6904807112121122133">"Druh(-žka)"</string>
    <string name="relationTypeFather" msgid="5228034687082050725">"Otec"</string>
    <string name="relationTypeFriend" msgid="7313106762483391262">"Kamarát(ka)"</string>
    <string name="relationTypeManager" msgid="6365677861610137895">"Vedúci(-a)"</string>
    <string name="relationTypeMother" msgid="4578571352962758304">"Matka"</string>
    <string name="relationTypeParent" msgid="4755635567562925226">"Rodič"</string>
    <string name="relationTypePartner" msgid="7266490285120262781">"Partner(ka)"</string>
    <string name="relationTypeReferredBy" msgid="101573059844135524">"Odporučenie"</string>
    <string name="relationTypeRelative" msgid="1799819930085610271">"Príbuzný(-á)"</string>
    <string name="relationTypeSister" msgid="1735983554479076481">"Sestra"</string>
    <string name="relationTypeSpouse" msgid="394136939428698117">"Manžel(ka)"</string>
    <string name="sipAddressTypeCustom" msgid="2473580593111590945">"Vlastné"</string>
    <string name="sipAddressTypeHome" msgid="6093598181069359295">"Domov"</string>
    <string name="sipAddressTypeWork" msgid="6920725730797099047">"Práca"</string>
    <string name="sipAddressTypeOther" msgid="4408436162950119849">"Iné"</string>
    <string name="quick_contacts_not_available" msgid="746098007828579688">"Nebola nájdená žiadna aplikácia, pomocou ktorej by bolo možné zobraziť tento kontakt."</string>
    <string name="keyguard_password_enter_pin_code" msgid="3037685796058495017">"Zadajte kód PIN"</string>
    <string name="keyguard_password_enter_puk_code" msgid="4800725266925845333">"Zadajte kód PUK a nový kód PIN"</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="1341112146710087048">"Kód PUK"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="8027680321614196258">"Nový kód PIN"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="2644215452200037944"><font size="17">"Klepnutím zadajte heslo"</font></string>
    <string name="keyguard_password_enter_password_code" msgid="1054721668279049780">"Zadajte heslo na odomknutie"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="6391755146112503443">"Zadajte kód PIN na odomknutie"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="2422225591006134936">"Nesprávny kód PIN."</string>
    <string name="keyguard_label_text" msgid="861796461028298424">"Ak chcete telefón odomknúť, stlačte Menu a následne 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="696192103195090970">"Číslo tiesňovej linky"</string>
    <string name="lockscreen_carrier_default" msgid="6169005837238288522">"Žiadny signál"</string>
    <string name="lockscreen_screen_locked" msgid="7288443074806832904">"Obrazovka je uzamknutá."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="46154051614126049">"Ak chcete odomknúť telefón alebo uskutočniť tiesňové volanie, stlačte Menu."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="686260028797158364">"Telefón odomknete stlačením tlačidla Menu."</string>
    <string name="lockscreen_pattern_instructions" msgid="7478703254964810302">"Odomknite nakreslením vzoru"</string>
    <string name="lockscreen_emergency_call" msgid="5298642613417801888">"Stav tiesne"</string>
    <string name="lockscreen_return_to_call" msgid="5244259785500040021">"Zavolať späť"</string>
    <string name="lockscreen_pattern_correct" msgid="9039008650362261237">"Správne!"</string>
    <string name="lockscreen_pattern_wrong" msgid="4317955014948108794">"Skúsiť znova"</string>
    <string name="lockscreen_password_wrong" msgid="5737815393253165301">"Skúsiť znova"</string>
    <string name="lockscreen_storage_locked" msgid="9167551160010625200">"Všetky funkcie a dáta získate po odomknutí"</string>
    <string name="faceunlock_multiple_failures" msgid="754137583022792429">"Prekročili ste maximálny povolený počet pokusov o odomknutie tvárou"</string>
    <string name="lockscreen_missing_sim_message_short" msgid="5099439277819215399">"Žiadna SIM karta"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="151659196095791474">"V tablete nie je žiadna SIM karta."</string>
    <string name="lockscreen_missing_sim_message" product="tv" msgid="1943633865476989599">"V televízore nie je žiadna SIM karta."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="2186920585695169078">"V telefóne nie je žiadna SIM karta."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="5372787138023272615">"Vložte SIM kartu."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3526573099019319472">"SIM karta chýba alebo sa z nej nedá čítať. Vložte SIM kartu."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="5096149665138916184">"SIM karta je nepoužiteľná."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="910904643433151371">"Vaša SIM karta bola natrvalo zakázaná.\nAk chcete získať inú SIM kartu, kontaktujte svojho operátora."</string>
    <string name="lockscreen_transport_prev_description" msgid="6300840251218161534">"Predchádzajúca stopa"</string>
    <string name="lockscreen_transport_next_description" msgid="573285210424377338">"Ďalšia stopa"</string>
    <string name="lockscreen_transport_pause_description" msgid="3980308465056173363">"Pozastaviť"</string>
    <string name="lockscreen_transport_play_description" msgid="1901258823643886401">"Prehrať"</string>
    <string name="lockscreen_transport_stop_description" msgid="5907083260651210034">"Zastaviť"</string>
    <string name="lockscreen_transport_rew_description" msgid="6944412838651990410">"Pretočiť späť"</string>
    <string name="lockscreen_transport_ffw_description" msgid="42987149870928985">"Pretočiť dopredu"</string>
    <string name="emergency_calls_only" msgid="6733978304386365407">"Len tiesňové volania"</string>
    <string name="lockscreen_network_locked_message" msgid="143389224986028501">"Sieť je zablokovaná"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="7441797339976230">"SIM karta je uzamknutá pomocou kódu PUK."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="8127916255245181063">"Prečítajte si Príručku používateľa alebo kontaktujte podporu zákazníka."</string>
    <string name="lockscreen_sim_locked_message" msgid="8066660129206001039">"SIM karta je uzamknutá."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="595323214052881264">"Prebieha odomykanie SIM karty..."</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6481623830344107222">"<xliff:g id="NUMBER_0">%1$d</xliff:g>-krát ste použili nesprávny bezpečnostný vzor. \n\nSkúste to znova o <xliff:g id="NUMBER_1">%2$d</xliff:g> s."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="2725973286239344555">"<xliff:g id="NUMBER_0">%1$d</xliff:g>-krát ste zadali nesprávne heslo. \n\nSkúste to znova o <xliff:g id="NUMBER_1">%2$d</xliff:g> s."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="6216672706545696955">"<xliff:g id="NUMBER_0">%1$d</xliff:g>-krát ste zadali nesprávny kód PIN. \n\nSkúste to znova o <xliff:g id="NUMBER_1">%2$d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="9191611984625460820">"<xliff:g id="NUMBER_0">%1$d</xliff:g>-krát ste nesprávne nakreslili svoj bezpečnostný vzor. Po ďalších neúspešných pokusoch (<xliff:g id="NUMBER_1">%2$d</xliff:g>) budete vyzvaní odomknúť tablet pomocou prihlasovacích údajov služby Google.\n\n Skúste to znova o <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tv" msgid="5316664559603394684">"Vzor na odomknutie ste nesprávne nakreslili <xliff:g id="NUMBER_0">%1$d</xliff:g>-krát. Po ďalších neúspešných pokusoch (počet: <xliff:g id="NUMBER_1">%2$d</xliff:g>) sa zobrazí výzva na odomknutie vášho televízora pomocou prihlásenia Google.\n\n Skúste to znova o <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="2590227559763762751">"<xliff:g id="NUMBER_0">%1$d</xliff:g>-krát ste nesprávne nakreslili svoj bezpečnostný vzor. Po <xliff:g id="NUMBER_1">%2$d</xliff:g> ďalších neúspešných pokusoch sa zobrazí výzva na odomknutie telefónu pomocou prihlasovacích údajov Google.\n\n Skúste to znova o <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="6128106399745755604">"Tablet ste sa pokúsili odomknúť nesprávnym spôsobom <xliff:g id="NUMBER_0">%1$d</xliff:g>-krát. Po <xliff:g id="NUMBER_1">%2$d</xliff:g> ďalších neúspešných pokusoch sa v tablete obnovia predvolené výrobné nastavenia a všetky používateľské údaje budú stratené."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tv" msgid="950408382418270260">"Televízor ste sa pokúsili nesprávne odomknúť <xliff:g id="NUMBER_0">%1$d</xliff:g>-krát. Po ďalších neúspešných pokusoch (počet: <xliff:g id="NUMBER_1">%2$d</xliff:g>) sa obnovia výrobné nastavenia televízora a prídete o všetky údaje používateľa."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="8603565142156826565">"Telefón ste sa pokúsili odomknúť nesprávnym spôsobom <xliff:g id="NUMBER_0">%1$d</xliff:g>-krát. Po <xliff:g id="NUMBER_1">%2$d</xliff:g> ďalších neúspešných pokusoch sa v telefóne obnovia predvolené výrobné nastavenia a všetky používateľské údaje budú stratené."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="280873516493934365">"Tablet ste sa pokúsili odomknúť nesprávnym spôsobom <xliff:g id="NUMBER">%d</xliff:g>-krát. V tablete sa teraz obnovia predvolené výrobné nastavenia."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tv" msgid="3195755534096192191">"Televízor ste sa pokúsili nesprávne odomknúť <xliff:g id="NUMBER">%d</xliff:g>-krát. Teraz v ňom budú obnovené výrobné nastavenia."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="3025504721764922246">"Telefón ste sa pokúsili odomknúť nesprávnym spôsobom <xliff:g id="NUMBER">%d</xliff:g>-krát. V telefóne sa teraz obnovia predvolené výrobné nastavenia."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6251480343394389665">"Počet sekúnd zostávajúcich do ďalšieho pokusu: <xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="2626999449610695930">"Zabudli ste vzor?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="2588521501166032747">"Odomknutie účtu"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="2751368605287288808">"Príliš veľa pokusov o nakreslenie vzoru"</string>
    <string name="lockscreen_glogin_instructions" msgid="3931816256100707784">"Ak chcete telefón odomknúť, prihláste sa pomocou svojho účtu Google."</string>
    <string name="lockscreen_glogin_username_hint" msgid="8846881424106484447">"Používateľské meno (e-mail)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="5958028383954738528">"Heslo"</string>
    <string name="lockscreen_glogin_submit_button" msgid="7130893694795786300">"Prihlásiť sa"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="1364051473347485908">"Neplatné používateľské meno alebo heslo."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1696924763690379073">"Zabudli ste používateľské meno alebo heslo?\nNavštívte stránky "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="lockscreen_glogin_checking_password" msgid="7114627351286933867">"Prebieha kontrola…"</string>
    <string name="lockscreen_unlock_label" msgid="737440483220667054">"Odomknúť"</string>
    <string name="lockscreen_sound_on_label" msgid="9068877576513425970">"Zapnúť zvuk"</string>
    <string name="lockscreen_sound_off_label" msgid="996822825154319026">"Vypnúť zvuk"</string>
    <string name="lockscreen_access_pattern_start" msgid="3941045502933142847">"Bezpečnostný vzor bol začatý"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="5583479721001639579">"Bezpečnostný vzor bol vymazaný"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6756031208359292487">"Bunka bola pridaná"</string>
    <string name="lockscreen_access_pattern_cell_added_verbose" msgid="7264580781744026939">"Bola pridaná bunka <xliff:g id="CELL_INDEX">%1$s</xliff:g>"</string>
    <string name="lockscreen_access_pattern_detected" msgid="4988730895554057058">"Bezpečnostný vzor bol dokončený"</string>
    <string name="lockscreen_access_pattern_area" msgid="400813207572953209">"Oblasť na zadanie bezpečnostného vzoru."</string>
    <string name="keyguard_accessibility_widget_changed" msgid="5678624624681400191">"%1$s. Miniaplikácia %2$d z %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8273277058724924654">"Pridať miniaplikáciu."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="1281505703307930757">"Prázdne"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="2278106022311170299">"Oblasť na odomknutie bola rozšírená."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="6366992066936076396">"Oblasť na odomknutie bola zúžená."</string>
    <string name="keyguard_accessibility_widget" msgid="6527131039741808240">"Miniaplikácia <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1226798370913698896">"Výber používateľa"</string>
    <string name="keyguard_accessibility_status" msgid="8008264603935930611">"Stav"</string>
    <string name="keyguard_accessibility_camera" msgid="8904231194181114603">"Fotoaparát"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="262209654292161806">"Ovládacie prvky médií"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="8736853615588828197">"Zmena usporiadania miniaplikácií sa začala."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="7170190950870468320">"Zmena usporiadania miniaplikácií sa skončila."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="4426204263929224434">"Miniaplikácia <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> bola odstránená."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="519859720934178024">"Rozšíriť oblasť na odomknutie."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2959928478764697254">"Odomknutie prejdením prstom."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="1490840706075246612">"Odomknutie vzorom."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="4817282543351718535">"Odomknutie tvárou."</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="2469687111784035046">"Odomknutie kódom PIN."</string>
    <string name="keyguard_accessibility_password_unlock" msgid="7675777623912155089">"Odomknutie heslom."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="7679891324509597904">"Oblasť na zadanie bezpečnostného vzoru."</string>
    <string name="keyguard_accessibility_slide_area" msgid="6736064494019979544">"Oblasť na prejdenie prstom."</string>
    <string name="password_keyboard_label_symbol_key" msgid="992280756256536042">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="8001096175167485649">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="1284820942620288678">"ALT"</string>
    <string name="granularity_label_character" msgid="7336470535385009523">"znak"</string>
    <string name="granularity_label_word" msgid="7075570328374918660">"slovo"</string>
    <string name="granularity_label_link" msgid="5815508880782488267">"odkaz"</string>
    <string name="granularity_label_line" msgid="5764267235026120888">"riadok"</string>
    <string name="factorytest_failed" msgid="5410270329114212041">"Továrenský test zlyhal"</string>
    <string name="factorytest_not_system" msgid="4435201656767276723">"Test FACTORY_TEST je možné uskutočniť iba pri balíčkoch nainštalovaných v priečinku /system/app."</string>
    <string name="factorytest_no_action" msgid="872991874799998561">"Nebol nájdený žiadny balíček umožňujúci test FACTORY_TEST."</string>
    <string name="factorytest_reboot" msgid="6320168203050791643">"Reštartovať"</string>
    <string name="js_dialog_title" msgid="1987483977834603872">"Stránka „<xliff:g id="TITLE">%s</xliff:g>“ uvádza:"</string>
    <string name="js_dialog_title_default" msgid="6961903213729667573">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="2619376555525116593">"Potvrďte prechod"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="3112752010600484130">"Opustiť stránku"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="5614861293026099715">"Zostať na tejto strane"</string>
    <string name="js_dialog_before_unload" msgid="3468816357095378590">"<xliff:g id="MESSAGE">%s</xliff:g>\n\nNaozaj chcete túto stránku opustiť?"</string>
    <string name="save_password_label" msgid="6860261758665825069">"Potvrdiť"</string>
    <string name="double_tap_toast" msgid="4595046515400268881">"Tip: Dvojitým klepnutím môžete zobrazenie priblížiť alebo oddialiť."</string>
    <string name="autofill_this_form" msgid="4616758841157816676">"Aut.dop."</string>
    <string name="setup_autofill" msgid="7103495070180590814">"Nast. Aut. dop."</string>
    <string name="autofill_address_name_separator" msgid="6350145154779706772">" "</string>
    <string name="autofill_address_summary_name_format" msgid="3268041054899214945">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="7483307893170324129">", "</string>
    <string name="autofill_address_summary_format" msgid="4874459455786827344">"$1$2$3"</string>
    <string name="autofill_province" msgid="2231806553863422300">"Provincia"</string>
    <string name="autofill_postal_code" msgid="4696430407689377108">"PSČ"</string>
    <string name="autofill_state" msgid="6988894195520044613">"Štát"</string>
    <string name="autofill_zip_code" msgid="8697544592627322946">"PSČ"</string>
    <string name="autofill_county" msgid="237073771020362891">"Kraj"</string>
    <string name="autofill_island" msgid="4020100875984667025">"Ostrov"</string>
    <string name="autofill_district" msgid="8400735073392267672">"Okres"</string>
    <string name="autofill_department" msgid="5343279462564453309">"Oddelenie"</string>
    <string name="autofill_prefecture" msgid="2028499485065800419">"Prefektúra"</string>
    <string name="autofill_parish" msgid="8202206105468820057">"Farnosť"</string>
    <string name="autofill_area" msgid="3547409050889952423">"Oblasť"</string>
    <string name="autofill_emirate" msgid="2893880978835698818">"Emirát"</string>
    <string name="permlab_readHistoryBookmarks" msgid="3775265775405106983">"čítať webové záložky a históriu"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="8462378226600439658">"Umožňuje aplikácii čítať všetky webové adresy navštívené prehliadačom a všetky záložky prehliadača. Poznámka: Toto povolenie nemôžu vynucovať prehliadače tretej strany ani iné aplikácie umožňujúce prehliadanie webu."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="3714785165273314490">"zapisovať webové záložky a históriu"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="6825527469145760922">"Umožňuje aplikácii upraviť históriu prehliadača alebo záložky uložené v tablete. Aplikácia s týmto povolením môže vymazať alebo upraviť údaje prehliadača. Poznámka: Toto povolenie nemôžu vynucovať prehliadače tretích strán ani žiadne ďalšie aplikácie umožňujúce prehliadanie webu."</string>
    <string name="permdesc_writeHistoryBookmarks" product="tv" msgid="7007393823197766548">"Umožňuje aplikácii upravovať históriu alebo záložky prehliadača uložené vo vašom televízore. Môže aplikácii umožniť vymazať alebo upraviť údaje prehliadača. Poznámka: Toto povolenie nemusia podporovať prehliadače tretích strán alebo iné aplikácie s možnosťami na prehliadanie webu."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="8497389531014185509">"Umožňuje aplikácii upraviť históriu prehliadača alebo záložky uložené v telefóne. Aplikácia s týmto povolením môže vymazať alebo upraviť údaje prehliadača. Poznámka: Toto povolenie nemôžu vynucovať prehliadače tretích strán ani žiadne ďalšie aplikácie umožňujúce prehliadanie webu."</string>
    <string name="permlab_setAlarm" msgid="1379294556362091814">"nastaviť budík"</string>
    <string name="permdesc_setAlarm" msgid="316392039157473848">"Umožňuje aplikácii nastaviť budík v nainštalovanej aplikácii budík. Niektoré aplikácie budíka nemusia túto funkciu implementovať."</string>
    <string name="permlab_addVoicemail" msgid="5525660026090959044">"pridať hlasovú schránku"</string>
    <string name="permdesc_addVoicemail" msgid="6604508651428252437">"Umožní aplikácii pridávať správy do doručenej pošty hlasovej schránky."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="5962224158955273932">"zmeniť povolenia prehliadača poskytovať informácie o zemepisnej polohe"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="1083743234522638747">"Umožňuje aplikácii zmeniť povolenia prehliadača na poskytovanie údajov o zemepisnej polohe. Škodlivé aplikácie to môžu použiť na odosielanie informácií o polohe ľubovoľným webovým stránkam."</string>
    <string name="save_password_message" msgid="767344687139195790">"Chcete, aby si prehliadač zapamätal toto heslo?"</string>
    <string name="save_password_notnow" msgid="6389675316706699758">"Teraz nie"</string>
    <string name="save_password_remember" msgid="6491879678996749466">"Zapamätať"</string>
    <string name="save_password_never" msgid="8274330296785855105">"Nikdy"</string>
    <string name="open_permission_deny" msgid="7374036708316629800">"Nemáte povolenie na otvorenie tejto stránky."</string>
    <string name="text_copied" msgid="4985729524670131385">"Text bol skopírovaný do schránky."</string>
    <string name="more_item_label" msgid="4650918923083320495">"Viac"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Menu+"</string>
    <string name="menu_space_shortcut_label" msgid="2410328639272162537">"medzera"</string>
    <string name="menu_enter_shortcut_label" msgid="2743362785111309668">"potvrdiť"</string>
    <string name="menu_delete_shortcut_label" msgid="3658178007202748164">"odstrániť"</string>
    <string name="search_go" msgid="8298016669822141719">"Hľadať"</string>
    <string name="search_hint" msgid="1733947260773056054">"Vyhľadávanie…"</string>
    <string name="searchview_description_search" msgid="6749826639098512120">"Hľadať"</string>
    <string name="searchview_description_query" msgid="5911778593125355124">"Vyhľadávací dopyt"</string>
    <string name="searchview_description_clear" msgid="1330281990951833033">"Jasný dopyt"</string>
    <string name="searchview_description_submit" msgid="2688450133297983542">"Odoslať dopyt"</string>
    <string name="searchview_description_voice" msgid="2453203695674994440">"Hlasové vyhľadávanie"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="7460694070309730149">"Chcete zapnúť Preskúmanie dotykom?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="8655887539089910577">"Služba <xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> požaduje povolenie funkcie Preskúmanie dotykom. Ak je funkcia Preskúmanie dotykom zapnutá, môžete počuť alebo vidieť popisy objektov pod vaším prstom alebo ovládať tablet gestami."</string>
    <string name="enable_explore_by_touch_warning_message" product="default" msgid="2708199672852373195">"Služba <xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> požaduje povolenie funkcie Preskúmanie dotykom. Ak je funkcia Preskúmanie dotykom zapnutá, môžete počuť alebo vidieť popisy objektov pod vaším prstom alebo ovládať telefón gestami."</string>
    <string name="oneMonthDurationPast" msgid="7396384508953779925">"pred 1 mesiacom"</string>
    <string name="beforeOneMonthDurationPast" msgid="909134546836499826">"Viac ako pred 1 mesiacom"</string>
    <plurals name="last_num_days" formatted="false" msgid="5104533550723932025">
      <item quantity="few">Posledné <xliff:g id="COUNT_1">%d</xliff:g> dni</item>
      <item quantity="many">Posledného <xliff:g id="COUNT_1">%d</xliff:g> dňa</item>
      <item quantity="other">Posledných <xliff:g id="COUNT_1">%d</xliff:g> dní</item>
      <item quantity="one">Posledný <xliff:g id="COUNT_0">%d</xliff:g> deň</item>
    </plurals>
    <string name="last_month" msgid="3959346739979055432">"Minulý mesiac"</string>
    <string name="older" msgid="5211975022815554840">"Staršie"</string>
    <string name="preposition_for_date" msgid="9093949757757445117">"dňa <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="5506831244263083793">"o <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="5040395640711867177">"z <xliff:g id="YEAR">%s</xliff:g>"</string>
    <string name="day" msgid="8144195776058119424">"deň"</string>
    <string name="days" msgid="4774547661021344602">"dní"</string>
    <string name="hour" msgid="2126771916426189481">"hodina"</string>
    <string name="hours" msgid="894424005266852993">"hodiny"</string>
    <string name="minute" msgid="9148878657703769868">"min"</string>
    <string name="minutes" msgid="5646001005827034509">"min"</string>
    <string name="second" msgid="3184235808021478">"s"</string>
    <string name="seconds" msgid="3161515347216589235">"s"</string>
    <string name="week" msgid="5617961537173061583">"týždeň"</string>
    <string name="weeks" msgid="6509623834583944518">"týždne"</string>
    <string name="year" msgid="4001118221013892076">"rok"</string>
    <string name="years" msgid="6881577717993213522">"roky"</string>
    <string name="now_string_shortest" msgid="8912796667087856402">"teraz"</string>
    <plurals name="duration_minutes_shortest" formatted="false" msgid="3957499975064245495">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>min</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g>min</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>min</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g>min</item>
    </plurals>
    <plurals name="duration_hours_shortest" formatted="false" msgid="3552182110578602356">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g>h</item>
    </plurals>
    <plurals name="duration_days_shortest" formatted="false" msgid="5213655532597081640">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g>d</item>
    </plurals>
    <plurals name="duration_years_shortest" formatted="false" msgid="7848711145196397042">
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>r</item>
      <item quantity="many"><xliff:g id="COUNT_1">%d</xliff:g>r</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>r</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g>r</item>
    </plurals>
    <plurals name="duration_minutes_shortest_future" formatted="false" msgid="3277614521231489951">
      <item quantity="few">o <xliff:g id="COUNT_1">%d</xliff:g>min</item>
      <item quantity="many">o <xliff:g id="COUNT_1">%d</xliff:g>min</item>
      <item quantity="other">o <xliff:g id="COUNT_1">%d</xliff:g>min</item>
      <item quantity="one">o <xliff:g id="COUNT_0">%d</xliff:g>min</item>
    </plurals>
    <plurals name="duration_hours_shortest_future" formatted="false" msgid="2152452368397489370">
      <item quantity="few">o <xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="many">o <xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="other">o <xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="one">o <xliff:g id="COUNT_0">%d</xliff:g>h</item>
    </plurals>
    <plurals name="duration_days_shortest_future" formatted="false" msgid="8088331502820295701">
      <item quantity="few">o <xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="many">o <xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="other">o <xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="one">o <xliff:g id="COUNT_0">%d</xliff:g>d</item>
    </plurals>
    <plurals name="duration_years_shortest_future" formatted="false" msgid="2317006667145250301">
      <item quantity="few">o <xliff:g id="COUNT_1">%d</xliff:g>r</item>
      <item quantity="many">o <xliff:g id="COUNT_1">%d</xliff:g>r</item>
      <item quantity="other">o <xliff:g id="COUNT_1">%d</xliff:g>r</item>
      <item quantity="one">o <xliff:g id="COUNT_0">%d</xliff:g>r</item>
    </plurals>
    <plurals name="duration_minutes_relative" formatted="false" msgid="3178131706192980192">
      <item quantity="few">pred <xliff:g id="COUNT_1">%d</xliff:g> minútami</item>
      <item quantity="many">pred <xliff:g id="COUNT_1">%d</xliff:g> minútou</item>
      <item quantity="other">pred <xliff:g id="COUNT_1">%d</xliff:g> minútami</item>
      <item quantity="one">pred <xliff:g id="COUNT_0">%d</xliff:g> minútou</item>
    </plurals>
    <plurals name="duration_hours_relative" formatted="false" msgid="676894109982008411">
      <item quantity="few">pred <xliff:g id="COUNT_1">%d</xliff:g> hodinami</item>
      <item quantity="many">pred <xliff:g id="COUNT_1">%d</xliff:g> hodinou</item>
      <item quantity="other">pred <xliff:g id="COUNT_1">%d</xliff:g> hodinami</item>
      <item quantity="one">pred <xliff:g id="COUNT_0">%d</xliff:g> hodinou</item>
    </plurals>
    <plurals name="duration_days_relative" formatted="false" msgid="2203515825765397130">
      <item quantity="few">pred <xliff:g id="COUNT_1">%d</xliff:g> dňami</item>
      <item quantity="many">pred <xliff:g id="COUNT_1">%d</xliff:g> dňom</item>
      <item quantity="other">pred <xliff:g id="COUNT_1">%d</xliff:g> dňami</item>
      <item quantity="one">pred <xliff:g id="COUNT_0">%d</xliff:g> dňom</item>
    </plurals>
    <plurals name="duration_years_relative" formatted="false" msgid="4820062134188885734">
      <item quantity="few">pred <xliff:g id="COUNT_1">%d</xliff:g> rokmi</item>
      <item quantity="many">pred <xliff:g id="COUNT_1">%d</xliff:g> rokom</item>
      <item quantity="other">pred <xliff:g id="COUNT_1">%d</xliff:g> rokmi</item>
      <item quantity="one">pred <xliff:g id="COUNT_0">%d</xliff:g> rokom</item>
    </plurals>
    <plurals name="duration_minutes_relative_future" formatted="false" msgid="4655043589817680966">
      <item quantity="few">o <xliff:g id="COUNT_1">%d</xliff:g> minúty</item>
      <item quantity="many">o <xliff:g id="COUNT_1">%d</xliff:g> minúty</item>
      <item quantity="other">o <xliff:g id="COUNT_1">%d</xliff:g> minút</item>
      <item quantity="one">o <xliff:g id="COUNT_0">%d</xliff:g> minútu</item>
    </plurals>
    <plurals name="duration_hours_relative_future" formatted="false" msgid="8084579714205223891">
      <item quantity="few">o <xliff:g id="COUNT_1">%d</xliff:g> hodiny</item>
      <item quantity="many">o <xliff:g id="COUNT_1">%d</xliff:g> hodiny</item>
      <item quantity="other">o <xliff:g id="COUNT_1">%d</xliff:g> hodín</item>
      <item quantity="one">o <xliff:g id="COUNT_0">%d</xliff:g> hodinu</item>
    </plurals>
    <plurals name="duration_days_relative_future" formatted="false" msgid="333215369363433992">
      <item quantity="few">o <xliff:g id="COUNT_1">%d</xliff:g> dni</item>
      <item quantity="many">o <xliff:g id="COUNT_1">%d</xliff:g> dňa</item>
      <item quantity="other">o <xliff:g id="COUNT_1">%d</xliff:g> dní</item>
      <item quantity="one">o <xliff:g id="COUNT_0">%d</xliff:g> deň</item>
    </plurals>
    <plurals name="duration_years_relative_future" formatted="false" msgid="8644862986413104011">
      <item quantity="few">o <xliff:g id="COUNT_1">%d</xliff:g> roky</item>
      <item quantity="many">o <xliff:g id="COUNT_1">%d</xliff:g> roka</item>
      <item quantity="other">o <xliff:g id="COUNT_1">%d</xliff:g> rokov</item>
      <item quantity="one">o <xliff:g id="COUNT_0">%d</xliff:g> rok</item>
    </plurals>
    <string name="VideoView_error_title" msgid="3534509135438353077">"Problém s videom"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3186670335938670444">"Je nám ľúto, ale toto video sa nedá streamovať do tohto zariadenia."</string>
    <string name="VideoView_error_text_unknown" msgid="3450439155187810085">"Toto video nie je možné prehrať."</string>
    <string name="VideoView_error_button" msgid="2822238215100679592">"OK"</string>
    <string name="relative_time" msgid="1818557177829411417">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="7245353528818587908">"poludnie"</string>
    <string name="Noon" msgid="3342127745230013127">"Poludnie"</string>
    <string name="midnight" msgid="7166259508850457595">"polnoc"</string>
    <string name="Midnight" msgid="5630806906897892201">"Polnoc"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="4431555943828711473">"<xliff:g id="MINUTES">%1$02d</xliff:g>:<xliff:g id="SECONDS">%2$02d</xliff:g>"</string>
    <string name="elapsed_time_short_format_h_mm_ss" msgid="1846071997616654124">"<xliff:g id="HOURS">%1$d</xliff:g>:<xliff:g id="MINUTES">%2$02d</xliff:g>:<xliff:g id="SECONDS">%3$02d</xliff:g>"</string>
    <string name="selectAll" msgid="6876518925844129331">"Vybrať všetko"</string>
    <string name="cut" msgid="3092569408438626261">"Vystrihnúť"</string>
    <string name="copy" msgid="2681946229533511987">"Kopírovať"</string>
    <string name="paste" msgid="5629880836805036433">"Prilepiť"</string>
    <string name="paste_as_plain_text" msgid="5427792741908010675">"Prilepiť ako obyčajný text"</string>
    <string name="replace" msgid="5781686059063148930">"Nahradiť•"</string>
    <string name="delete" msgid="6098684844021697789">"Odstrániť"</string>
    <string name="copyUrl" msgid="2538211579596067402">"Skopírovať webovú adresu"</string>
    <string name="selectTextMode" msgid="1018691815143165326">"Vybrať text"</string>
    <string name="undo" msgid="7905788502491742328">"Späť"</string>
    <string name="redo" msgid="7759464876566803888">"Znova"</string>
    <string name="autofill" msgid="3035779615680565188">"Automatické dopĺňanie"</string>
    <string name="textSelectionCABTitle" msgid="5236850394370820357">"Výber textu"</string>
    <string name="addToDictionary" msgid="4352161534510057874">"Pridať do slovníka"</string>
    <string name="deleteText" msgid="6979668428458199034">"Odstrániť"</string>
    <string name="inputMethod" msgid="1653630062304567879">"Metóda vstupu"</string>
    <string name="editTextMenuTitle" msgid="4909135564941815494">"Operácie s textom"</string>
    <string name="email" msgid="4560673117055050403">"E-mail"</string>
    <string name="dial" msgid="4204975095406423102">"Telefón"</string>
    <string name="map" msgid="6068210738233985748">"Mapy"</string>
    <string name="browse" msgid="6993590095938149861">"Prehliadač"</string>
    <string name="low_internal_storage_view_title" msgid="5576272496365684834">"Nedostatok ukladacieho priestoru"</string>
    <string name="low_internal_storage_view_text" msgid="6640505817617414371">"Niektoré systémové funkcie nemusia fungovať"</string>
    <string name="low_internal_storage_view_text_no_boot" msgid="6935190099204693424">"V úložisku nie je dostatok voľného miesta pre systém. Zaistite, aby ste mali 250 MB voľného miesta a zariadenie reštartujte."</string>
    <string name="app_running_notification_title" msgid="8718335121060787914">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> je spustená"</string>
    <string name="app_running_notification_text" msgid="1197581823314971177">"Klepnutím zobrazíte ďalšie informácie alebo zastavíte aplikáciu."</string>
    <string name="ok" msgid="5970060430562524910">"OK"</string>
    <string name="cancel" msgid="6442560571259935130">"Zrušiť"</string>
    <string name="yes" msgid="5362982303337969312">"OK"</string>
    <string name="no" msgid="5141531044935541497">"Zrušiť"</string>
    <string name="close" msgid="2318214661230355730">"ZAVRIEŤ"</string>
    <string name="dialog_alert_title" msgid="2049658708609043103">"Upozornenie"</string>
    <string name="loading" msgid="7933681260296021180">"Načítava sa…"</string>
    <string name="capital_on" msgid="1544682755514494298">"I"</string>
    <string name="capital_off" msgid="6815870386972805832">"O"</string>
    <string name="whichApplication" msgid="4533185947064773386">"Dokončiť akciu pomocou aplikácie"</string>
    <string name="whichApplicationNamed" msgid="8260158865936942783">"Dokončiť akciu pomocou aplikácie %1$s"</string>
    <string name="whichApplicationLabel" msgid="7425855495383818784">"Dokončiť akciu"</string>
    <string name="whichViewApplication" msgid="3272778576700572102">"Otvoriť v aplikácii"</string>
    <string name="whichViewApplicationNamed" msgid="2286418824011249620">"Otvoriť v aplikácii %1$s"</string>
    <string name="whichViewApplicationLabel" msgid="2666774233008808473">"Otvoriť"</string>
    <string name="whichEditApplication" msgid="144727838241402655">"Upraviť pomocou"</string>
    <string name="whichEditApplicationNamed" msgid="1775815530156447790">"Upraviť v aplikácii %1$s"</string>
    <string name="whichEditApplicationLabel" msgid="7183524181625290300">"Upraviť"</string>
    <string name="whichSendApplication" msgid="6902512414057341668">"Zdieľať"</string>
    <string name="whichSendApplicationNamed" msgid="2799370240005424391">"Zdieľať v aplikácii %1$s"</string>
    <string name="whichSendApplicationLabel" msgid="4579076294675975354">"Zdieľať"</string>
    <string name="whichSendToApplication" msgid="8272422260066642057">"Odoslať pomocou aplikácie"</string>
    <string name="whichSendToApplicationNamed" msgid="7768387871529295325">"Odoslať pomocou aplikácie %1$s"</string>
    <string name="whichSendToApplicationLabel" msgid="8878962419005813500">"Odoslať"</string>
    <string name="whichHomeApplication" msgid="4307587691506919691">"Výber aplikácie na plochu"</string>
    <string name="whichHomeApplicationNamed" msgid="4493438593214760979">"Ako plochu používať aplikáciu %1$s"</string>
    <string name="whichHomeApplicationLabel" msgid="809529747002918649">"Nasnímať fotografiu"</string>
    <string name="whichImageCaptureApplication" msgid="3680261417470652882">"Nasnímať fotografiu pomocou aplikácie"</string>
    <string name="whichImageCaptureApplicationNamed" msgid="8619384150737825003">"Nasnímať fotografiu pomocou aplikácie %1$s"</string>
    <string name="whichImageCaptureApplicationLabel" msgid="6390303445371527066">"Nasnímať fotografiu"</string>
    <string name="alwaysUse" msgid="4583018368000610438">"Použiť ako predvolené nastavenie pre túto akciu."</string>
    <string name="use_a_different_app" msgid="8134926230585710243">"Použiť inú aplikáciu"</string>
    <string name="clearDefaultHintMsg" msgid="3252584689512077257">"Vymazať predvolené nastavenia v sekcii Nastavenia systému &gt; Aplikácie &gt; Stiahnuté položky."</string>
    <string name="chooseActivity" msgid="7486876147751803333">"Zvoľte akciu"</string>
    <string name="chooseUsbActivity" msgid="6894748416073583509">"Zvoľte aplikáciu pre zariadenie USB"</string>
    <string name="noApplications" msgid="2991814273936504689">"Túto akciu nemôžu vykonávať žiadne aplikácie."</string>
    <string name="aerr_application" msgid="250320989337856518">"<xliff:g id="APPLICATION">%1$s</xliff:g> sa zastavila"</string>
    <string name="aerr_process" msgid="6201597323218674729">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> sa zastavil"</string>
    <string name="aerr_application_repeated" msgid="3146328699537439573">"<xliff:g id="APPLICATION">%1$s</xliff:g> sa opakovane zastavuje"</string>
    <string name="aerr_process_repeated" msgid="6235302956890402259">"<xliff:g id="PROCESS">%1$s</xliff:g> sa opakovane zastavuje"</string>
    <string name="aerr_restart" msgid="7581308074153624475">"Spustiť aplikáciu znova"</string>
    <string name="aerr_report" msgid="5371800241488400617">"Odoslať spätnú väzbu"</string>
    <string name="aerr_close" msgid="2991640326563991340">"Zavrieť"</string>
    <string name="aerr_mute" msgid="1974781923723235953">"Ignorovať do reštartu zariadenia"</string>
    <string name="aerr_wait" msgid="3199956902437040261">"Čakať"</string>
    <string name="aerr_close_app" msgid="3269334853724920302">"Zavrieť aplikáciu"</string>
    <string name="anr_title" msgid="4351948481459135709"></string>
    <string name="anr_activity_application" msgid="8493290105678066167">"<xliff:g id="APPLICATION">%2$s</xliff:g> nereaguje"</string>
    <string name="anr_activity_process" msgid="1622382268908620314">"<xliff:g id="ACTIVITY">%1$s</xliff:g> nereaguje"</string>
    <string name="anr_application_process" msgid="6417199034861140083">"<xliff:g id="APPLICATION">%1$s</xliff:g> nereaguje"</string>
    <string name="anr_process" msgid="6156880875555921105">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> nereaguje"</string>
    <string name="force_close" msgid="8346072094521265605">"OK"</string>
    <string name="report" msgid="4060218260984795706">"Nahlásiť"</string>
    <string name="wait" msgid="7147118217226317732">"Čakajte"</string>
    <string name="webpage_unresponsive" msgid="3272758351138122503">"Stránka nereaguje.\n\nChcete ju zavrieť?"</string>
    <string name="launch_warning_title" msgid="1547997780506713581">"Presmerovaná aplikácia"</string>
    <string name="launch_warning_replace" msgid="6202498949970281412">"Je spustená aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="launch_warning_original" msgid="188102023021668683">"Pôvodne bola spustená aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="screen_compat_mode_scale" msgid="3202955667675944499">"Prispôsobiť veľkosť"</string>
    <string name="screen_compat_mode_show" msgid="4013878876486655892">"Vždy zobraziť"</string>
    <string name="screen_compat_mode_hint" msgid="1064524084543304459">"Povoľte to znova v sekcii Nastavenia systému &gt; Aplikácie &gt; Stiahnuté súbory."</string>
    <string name="top_app_killed_title" msgid="6814231368167994497">"Aplikácia nereaguje"</string>
    <string name="top_app_killed_message" msgid="3487519022191609844">"<xliff:g id="APP_NAME">%1$s</xliff:g> pravdepodobne používa príliš veľa pamäte."</string>
    <string name="unsupported_display_size_message" msgid="6545327290756295232">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> aktuálne nastavenie veľkosti zobrazenia nepodporuje a môže sa správať neočakávane."</string>
    <string name="unsupported_display_size_show" msgid="7969129195360353041">"Vždy zobrazovať"</string>
    <string name="smv_application" msgid="3307209192155442829">"Aplikácia <xliff:g id="APPLICATION">%1$s</xliff:g> (proces <xliff:g id="PROCESS">%2$s</xliff:g>) porušila svoje vlastné vynútené pravidlá StrictMode."</string>
    <string name="smv_process" msgid="5120397012047462446">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> porušil svoje vlastné vynútené pravidlá StrictMode."</string>
    <string name="android_upgrading_title" msgid="1584192285441405746">"Prebieha inovácia systému Android..."</string>
    <string name="android_start_title" msgid="8418054686415318207">"Systém Android sa spúšťa…"</string>
    <string name="android_upgrading_fstrim" msgid="8036718871534640010">"Optimalizuje sa úložisko"</string>
    <string name="android_upgrading_notification_title" msgid="8428357096969413169">"Dokončuje sa aktualizácia Androidu…"</string>
    <string name="android_upgrading_notification_body" msgid="5761201379457064286">"Niektoré aplikácie môžu správne fungovať až po dokončení inovácie"</string>
    <string name="app_upgrading_toast" msgid="3008139776215597053">"Aplikácia <xliff:g id="APPLICATION">%1$s</xliff:g> sa inovuje…"</string>
    <string name="android_upgrading_apk" msgid="7904042682111526169">"Prebieha optimalizácia aplikácie <xliff:g id="NUMBER_0">%1$d</xliff:g> z <xliff:g id="NUMBER_1">%2$d</xliff:g>."</string>
    <string name="android_preparing_apk" msgid="8162599310274079154">"Pripravuje sa aplikácia <xliff:g id="APPNAME">%1$s</xliff:g>."</string>
    <string name="android_upgrading_starting_apps" msgid="451464516346926713">"Prebieha spúšťanie aplikácií."</string>
    <string name="android_upgrading_complete" msgid="1405954754112999229">"Prebieha dokončovanie spúšťania."</string>
    <string name="heavy_weight_notification" msgid="9087063985776626166">"Spustená aplikácia: <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="heavy_weight_notification_detail" msgid="867643381388543170">"Klepnutím prepnite na aplikáciu"</string>
    <string name="heavy_weight_switcher_title" msgid="7153167085403298169">"Prepnúť aplikácie?"</string>
    <string name="heavy_weight_switcher_text" msgid="7022631924534406403">"Pred spustením novej aplikácie treba zastaviť inú spustenú aplikáciu."</string>
    <string name="old_app_action" msgid="493129172238566282">"Návrat k <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="old_app_description" msgid="2082094275580358049">"Nespúšťať novú aplikáciu."</string>
    <string name="new_app_action" msgid="5472756926945440706">"Spustiť <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="1932143598371537340">"Zastaviť starú aplikáciu bez uloženia."</string>
    <string name="dump_heap_notification" msgid="2618183274836056542">"Proces <xliff:g id="PROC">%1$s</xliff:g> prekročil limit pamäte"</string>
    <string name="dump_heap_notification_detail" msgid="6901391084243999274">"Boli zhromaždené zálohy údajov; zdieľajte ich klepnutím"</string>
    <string name="dump_heap_title" msgid="5864292264307651673">"Chcete zdieľať zálohy údajov?"</string>
    <string name="dump_heap_text" msgid="4809417337240334941">"Proces <xliff:g id="PROC">%1$s</xliff:g> prekročil limit <xliff:g id="SIZE">%2$s</xliff:g> pre pamäť procesu. Máte k dispozícii zálohy údajov, ktoré môžete zdieľať s vývojárom. Postupujte opatrne: tieto zálohy údajov nesmú obsahovať žiadne osobné informácie, ku ktorým má táto aplikácia prístup."</string>
    <string name="sendText" msgid="5209874571959469142">"Zvoľte akciu pre text"</string>
    <string name="volume_ringtone" msgid="6885421406845734650">"Hlasitosť vyzváňania"</string>
    <string name="volume_music" msgid="5421651157138628171">"Hlasitosť médií"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="9165984379394601533">"Prehrávanie pomocou rozhrania Bluetooth"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="8310739960973156272">"Je nastavený tichý tón zvonenia"</string>
    <string name="volume_call" msgid="3941680041282788711">"Hlasitosť hovoru"</string>
    <string name="volume_bluetooth_call" msgid="2002891926351151534">"Hlasitosť prichádzajúcich hovorov pri pripojení Bluetooth"</string>
    <string name="volume_alarm" msgid="1985191616042689100">"Hlasitosť budíkov"</string>
    <string name="volume_notification" msgid="2422265656744276715">"Hlasitosť upozornení"</string>
    <string name="volume_unknown" msgid="1400219669770445902">"Hlasitosť"</string>
    <string name="volume_icon_description_bluetooth" msgid="6538894177255964340">"Hlasitosť zariadenia Bluetooth"</string>
    <string name="volume_icon_description_ringer" msgid="3326003847006162496">"Hlasitosť zvonenia"</string>
    <string name="volume_icon_description_incall" msgid="8890073218154543397">"Hlasitosť hovoru"</string>
    <string name="volume_icon_description_media" msgid="4217311719665194215">"Hlasitosť médií"</string>
    <string name="volume_icon_description_notification" msgid="7044986546477282274">"Hlasitosť upozornení"</string>
    <string name="ringtone_default" msgid="3789758980357696936">"Predvolený tón zvonenia"</string>
    <string name="ringtone_default_with_actual" msgid="1767304850491060581">"Predvolený (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="7937634392408977062">"Žiadny"</string>
    <string name="ringtone_picker_title" msgid="3515143939175119094">"Tóny zvonenia"</string>
    <string name="ringtone_picker_title_alarm" msgid="6473325356070549702">"Zvuky budíka"</string>
    <string name="ringtone_picker_title_notification" msgid="4837740874822788802">"Zvuky upozornení"</string>
    <string name="ringtone_unknown" msgid="3914515995813061520">"Neznáme"</string>
    <plurals name="wifi_available" formatted="false" msgid="7900333017752027322">
      <item quantity="few">K dispozícii sú siete Wi‑Fi</item>
      <item quantity="many">K dispozícii sú siete Wi‑Fi</item>
      <item quantity="other">K dispozícii sú siete Wi‑Fi</item>
      <item quantity="one">K dispozícii je sieť Wi‑Fi</item>
    </plurals>
    <plurals name="wifi_available_detailed" formatted="false" msgid="1140699367193975606">
      <item quantity="few">K dispozícii sú verejné siete Wi‑Fi</item>
      <item quantity="many">K dispozícii sú verejné siete Wi‑Fi</item>
      <item quantity="other">K dispozícii sú verejné siete Wi‑Fi</item>
      <item quantity="one">K dispozícii je verejná sieť Wi‑Fi</item>
    </plurals>
    <string name="wifi_available_title" msgid="3817100557900599505">"Pripojenie k otvorenej sieti Wi‑Fi"</string>
    <string name="wifi_available_title_connecting" msgid="1557292688310330032">"Pripája sa k otvorenej sieti Wi‑Fi"</string>
    <string name="wifi_available_title_connected" msgid="7542672851522241548">"Pripojenie k sieti Wi‑Fi"</string>
    <string name="wifi_available_title_failed_to_connect" msgid="6861772233582618132">"K sieti Wi‑Fi sa nepodarilo pripojiť"</string>
    <string name="wifi_available_content_failed_to_connect" msgid="3377406637062802645">"Klepnutím zobrazíte všetky siete"</string>
    <string name="wifi_available_action_connect" msgid="2635699628459488788">"Pripojiť"</string>
    <string name="wifi_available_action_all_networks" msgid="1100098935861622985">"Všetky siete"</string>
    <string name="wifi_available_sign_in" msgid="9157196203958866662">"Prihlásiť sa do siete Wi‑Fi"</string>
    <string name="network_available_sign_in" msgid="1848877297365446605">"Prihlásenie do siete"</string>
    <!-- no translation found for network_available_sign_in_detailed (8000081941447976118) -->
    <skip />
    <string name="wifi_no_internet" msgid="8451173622563841546">"Sieť Wi‑Fi nemá prístup k internetu"</string>
    <string name="wifi_no_internet_detailed" msgid="8083079241212301741">"Klepnutím získate možnosti"</string>
    <string name="network_switch_metered" msgid="4671730921726992671">"Prepnuté na sieť: <xliff:g id="NETWORK_TYPE">%1$s</xliff:g>"</string>
    <string name="network_switch_metered_detail" msgid="5325661434777870353">"Keď sieť <xliff:g id="PREVIOUS_NETWORK">%2$s</xliff:g> nemá prístup k internetu, zariadenie používa sieť <xliff:g id="NEW_NETWORK">%1$s</xliff:g>. Môžu sa účtovať poplatky."</string>
    <string name="network_switch_metered_toast" msgid="5779283181685974304">"Prepnuté zo siete <xliff:g id="PREVIOUS_NETWORK">%1$s</xliff:g> na sieť <xliff:g id="NEW_NETWORK">%2$s</xliff:g>"</string>
  <string-array name="network_switch_type_name">
    <item msgid="3979506840912951943">"mobilné dáta"</item>
    <item msgid="75483255295529161">"Wi‑Fi"</item>
    <item msgid="6862614801537202646">"Bluetooth"</item>
    <item msgid="5447331121797802871">"Ethernet"</item>
    <item msgid="8257233890381651999">"VPN"</item>
  </string-array>
    <string name="network_switch_type_name_unknown" msgid="4552612897806660656">"neznámy typ siete"</string>
    <string name="wifi_watchdog_network_disabled" msgid="7904214231651546347">"Nepodarilo sa pripojiť k sieti Wi‑Fi"</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="5548780776418332675">" má nekvalitné internetové pripojenie."</string>
    <string name="wifi_connect_alert_title" msgid="8455846016001810172">"Povoliť pripojenie?"</string>
    <string name="wifi_connect_alert_message" msgid="6451273376815958922">"Aplikácia %1$s sa chce pripojiť k sieti Wi‑Fi %2$s"</string>
    <string name="wifi_connect_default_application" msgid="7143109390475484319">"Aplikácia"</string>
    <string name="wifi_p2p_dialog_title" msgid="97611782659324517">"Priame pripojenie Wi‑Fi"</string>
    <string name="wifi_p2p_turnon_message" msgid="2909250942299627244">"Spustiť priame pripojenie siete Wi‑Fi. Táto možnosť vypne sieť Wi‑Fi v režime klient alebo hotspot."</string>
    <string name="wifi_p2p_failed_message" msgid="3763669677935623084">"Priame pripojenie siete Wi‑Fi sa nepodarilo spustiť"</string>
    <string name="wifi_p2p_enabled_notification_title" msgid="2068321881673734886">"Priame pripojenie siete Wi‑Fi je zapnuté"</string>
    <string name="wifi_p2p_enabled_notification_message" msgid="8064677407830620023">"Klepnutím zobrazíte nastavenia"</string>
    <string name="accept" msgid="1645267259272829559">"Prijať"</string>
    <string name="decline" msgid="2112225451706137894">"Odmietnuť"</string>
    <string name="wifi_p2p_invitation_sent_title" msgid="1318975185112070734">"Pozvánka bola odoslaná"</string>
    <string name="wifi_p2p_invitation_to_connect_title" msgid="4958803948658533637">"Pozvánka na pripojenie"</string>
    <string name="wifi_p2p_from_message" msgid="570389174731951769">"Od:"</string>
    <string name="wifi_p2p_to_message" msgid="248968974522044099">"Komu:"</string>
    <string name="wifi_p2p_enter_pin_message" msgid="5920929550367828970">"Zadajte požadovaný kód PIN:"</string>
    <string name="wifi_p2p_show_pin_message" msgid="8530563323880921094">"PIN:"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tablet" msgid="8012981257742232475">"Tablet bude počas pripojenia k zariadeniu <xliff:g id="DEVICE_NAME">%1$s</xliff:g> od siete Wi‑Fi dočasne odpojený."</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tv" msgid="3087858235069421128">"Televízor sa počas pripojenia k zariadeniu <xliff:g id="DEVICE_NAME">%1$s</xliff:g> dočasne odpojí zo siete Wi‑Fi."</string>
    <string name="wifi_p2p_frequency_conflict_message" product="default" msgid="7363907213787469151">"Telefón bude počas pripojenia k zariadeniu <xliff:g id="DEVICE_NAME">%1$s</xliff:g> od siete Wi‑Fi dočasne odpojený."</string>
    <string name="select_character" msgid="3365550120617701745">"Vkladanie znakov"</string>
    <string name="sms_control_title" msgid="7296612781128917719">"Odosielanie správ SMS"</string>
    <string name="sms_control_message" msgid="3867899169651496433">"Aplikácia &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; posiela veľký počet správ SMS. Chcete tejto aplikácií povoliť, aby aj naďalej posielala správy?"</string>
    <string name="sms_control_yes" msgid="3663725993855816807">"Povoliť"</string>
    <string name="sms_control_no" msgid="625438561395534982">"Odmietnuť"</string>
    <string name="sms_short_code_confirm_message" msgid="1645436466285310855">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; chce odoslať správu na adresu &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="5873295990846059400">"Táto akcia "<b>"môže viesť k zaúčtovaniu poplatkov"</b>" na váš účet u mobilného operátora."</string>
    <string name="sms_premium_short_code_details" msgid="7869234868023975"><b>"Táto akcia povedie k zaúčtovaniu poplatku na váš účet u mobilného operátora."</b></string>
    <string name="sms_short_code_confirm_allow" msgid="4458878637111023413">"Odoslať"</string>
    <string name="sms_short_code_confirm_deny" msgid="2927389840209170706">"Zrušiť"</string>
    <string name="sms_short_code_remember_choice" msgid="5289538592272218136">"Zapamätať si voľbu"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="4960944133052287484">"Zmena v časti Nastavenia &gt; Aplikácie"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="3241181154869493368">"Vždy povoliť"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="446992765774269673">"Nikdy nepovoliť"</string>
    <string name="sim_removed_title" msgid="6227712319223226185">"SIM karta bola odobraná"</string>
    <string name="sim_removed_message" msgid="2333164559970958645">"Mobilná sieť nebude k dispozícii, kým nevložíte platnú SIM kartu a zariadenie nereštartujete."</string>
    <string name="sim_done_button" msgid="827949989369963775">"Hotovo"</string>
    <string name="sim_added_title" msgid="3719670512889674693">"Bola pridaná SIM karta"</string>
    <string name="sim_added_message" msgid="6599945301141050216">"Ak chcete získať prístup k mobilnej sieti, reštartujte svoje zariadenie."</string>
    <string name="sim_restart_button" msgid="4722407842815232347">"Reštartovať"</string>
    <string name="carrier_app_dialog_message" msgid="7066156088266319533">"Ak chcete, aby vaša nová SIM karta fungovala správne, musíte nainštalovať a spustiť aplikáciu od operátora."</string>
    <string name="carrier_app_dialog_button" msgid="7900235513678617329">"ZÍSKAŤ APLIKÁCIU"</string>
    <string name="carrier_app_dialog_not_now" msgid="6361378684292268027">"TERAZ NIE"</string>
    <string name="carrier_app_notification_title" msgid="8921767385872554621">"Bola vložená nová SIM karta"</string>
    <string name="carrier_app_notification_text" msgid="1132487343346050225">"Nastavte ju klepnutím"</string>
    <string name="time_picker_dialog_title" msgid="8349362623068819295">"Nastaviť čas"</string>
    <string name="date_picker_dialog_title" msgid="5879450659453782278">"Nastaviť dátum"</string>
    <string name="date_time_set" msgid="5777075614321087758">"Nastaviť"</string>
    <string name="date_time_done" msgid="2507683751759308828">"Hotovo"</string>
    <string name="perms_new_perm_prefix" msgid="8257740710754301407"><font size="12" fgcolor="#ff33b5e5">"NOVINKA: "</font></string>
    <string name="perms_description_app" msgid="5139836143293299417">"Poskytuje aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="no_permissions" msgid="7283357728219338112">"Nevyžadujú sa žiadne oprávnenia."</string>
    <string name="perm_costs_money" msgid="4902470324142151116">"môžu sa vám účtovať poplatky"</string>
    <string name="dlg_ok" msgid="7376953167039865701">"OK"</string>
    <string name="usb_charging_notification_title" msgid="6895185153353640787">"Zariadenie sa nabíja cez USB"</string>
    <string name="usb_supplying_notification_title" msgid="5310642257296510271">"Prebieha nabíjanie pripojeného zariadenia pomocou USB"</string>
    <string name="usb_mtp_notification_title" msgid="8396264943589760855">"USB na prenos súborov"</string>
    <string name="usb_ptp_notification_title" msgid="1347328437083192112">"USB na prenos fotiek"</string>
    <string name="usb_midi_notification_title" msgid="4850904915889144654">"USB na pripojenie zariadenia MIDI"</string>
    <string name="usb_accessory_notification_title" msgid="7848236974087653666">"Pripojené k periférnemu zariadeniu USB"</string>
    <string name="usb_notification_message" msgid="3370903770828407960">"Klepnutím zobrazíte ďalšie možnosti."</string>
    <string name="usb_unsupported_audio_accessory_title" msgid="3529881374464628084">"Bolo zistené analógové zvukové príslušenstvo"</string>
    <string name="usb_unsupported_audio_accessory_message" msgid="6309553946441565215">"Pripojené zariadenie nie je kompatibilné s týmto telefónom. Ďalšie informácie zobrazíte klepnutím."</string>
    <string name="adb_active_notification_title" msgid="6729044778949189918">"Ladenie cez USB pripojené"</string>
    <string name="adb_active_notification_message" msgid="4948470599328424059">"Klepnutím zakážete ladenie cez USB."</string>
    <string name="adb_active_notification_message" product="tv" msgid="8470296818270110396">"Vyberte, ak chcete zakázať ladenie cez USB."</string>
    <string name="taking_remote_bugreport_notification_title" msgid="6742483073875060934">"Preberá sa hlásenie chyby…"</string>
    <string name="share_remote_bugreport_notification_title" msgid="4987095013583691873">"Chcete zdieľať hlásenie chyby?"</string>
    <string name="sharing_remote_bugreport_notification_title" msgid="7572089031496651372">"Zdieľa sa hlásenie chyby…"</string>
    <string name="share_remote_bugreport_notification_message_finished" msgid="6029609949340992866">"Správca vyžiadal hlásenie chyby, aby mohol vyriešiť problém na tomto zariadení. Aplikácie a dáta môžu byť zdieľané."</string>
    <string name="share_remote_bugreport_action" msgid="6249476773913384948">"ZDIEĽAŤ"</string>
    <string name="decline_remote_bugreport_action" msgid="6230987241608770062">"ODMIETNUŤ"</string>
    <string name="select_input_method" msgid="8547250819326693584">"Zmeniť klávesnicu"</string>
    <string name="show_ime" msgid="2506087537466597099">"Ponechať na obrazovke, keď je aktívna fyzická klávesnica"</string>
    <string name="hardware" msgid="194658061510127999">"Zobraziť virtuálnu klávesnicu"</string>
    <string name="select_keyboard_layout_notification_title" msgid="597189518763083494">"Konfigurácia fyzickej klávesnice"</string>
    <string name="select_keyboard_layout_notification_message" msgid="8084622969903004900">"Klepnutím vyberte jazyk a rozloženie"</string>
    <string name="fast_scroll_alphabet" msgid="5433275485499039199">" AÁÄBCČDĎDZDŽEÉFGHCHIÍJKLĽMNŇOÓÔPRŔSŠTŤUÚVWXYÝZŽ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="4030170524595123610">" 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="alert_windows_notification_channel_group_name" msgid="1463953341148606396">"Zobrazenie cez iné aplikácie"</string>
    <string name="alert_windows_notification_channel_name" msgid="3116610965549449803">"<xliff:g id="NAME">%s</xliff:g> sa zobrazuje cez iné aplikácie"</string>
    <string name="alert_windows_notification_title" msgid="3697657294867638947">"<xliff:g id="NAME">%s</xliff:g> sa zobrazuje cez iné aplikácie"</string>
    <string name="alert_windows_notification_message" msgid="8917232109522912560">"Ak nechcete, aby aplikácia <xliff:g id="NAME">%s</xliff:g> používala túto funkciu, klepnutím otvorte nastavenia a vypnite ju."</string>
    <string name="alert_windows_notification_turn_off_action" msgid="3367294525884949878">"VYPNÚŤ"</string>
    <string name="ext_media_checking_notification_title" msgid="5734005953288045806">"Pripravuje sa úložisko <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_checking_notification_message" msgid="4747432538578886744">"Prebieha kontrola chýb"</string>
    <string name="ext_media_new_notification_message" msgid="7589986898808506239">"Bolo zistené nové úložisko <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_ready_notification_message" msgid="4083398150380114462">"Na prenos fotiek a médií"</string>
    <string name="ext_media_unmountable_notification_title" msgid="8295123366236989588">"Poškodené úložisko <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unmountable_notification_message" msgid="2343202057122495773">"Úložisko <xliff:g id="NAME">%s</xliff:g> je poškodené. Opravte ho klepnutím."</string>
    <string name="ext_media_unmountable_notification_message" product="tv" msgid="3941179940297874950">"Médium <xliff:g id="NAME">%s</xliff:g> je poškodené. Vyberte ho a vyriešte problém."</string>
    <string name="ext_media_unsupported_notification_title" msgid="3797642322958803257">"Nepodporované úložisko <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unsupported_notification_message" msgid="6121601473787888589">"Toto zariadenie nepodporuje úložisko <xliff:g id="NAME">%s</xliff:g>. Klepnutím ho nastavíte v podporovanom formáte."</string>
    <string name="ext_media_unsupported_notification_message" product="tv" msgid="3725436899820390906">"Toto zariadenie nepodporuje médium <xliff:g id="NAME">%s</xliff:g>. Vyberte ho a nastavte v podporovanom formáte."</string>
    <string name="ext_media_badremoval_notification_title" msgid="3206248947375505416">"Úl. <xliff:g id="NAME">%s</xliff:g> bolo neočakávane odobraté"</string>
    <string name="ext_media_badremoval_notification_message" msgid="380176703346946313">"Ak chcete zabrániť strate údajov, úložisko <xliff:g id="NAME">%s</xliff:g> pred odobratím odpojte"</string>
    <string name="ext_media_nomedia_notification_title" msgid="1704840188641749091">"Úložisko <xliff:g id="NAME">%s</xliff:g> bolo odobraté"</string>
    <string name="ext_media_nomedia_notification_message" msgid="6471542972147056586">"Úložisko <xliff:g id="NAME">%s</xliff:g> bolo odobraté. Vložte nové."</string>
    <string name="ext_media_unmounting_notification_title" msgid="640674168454809372">"Úložisko <xliff:g id="NAME">%s</xliff:g> sa stále odpája…"</string>
    <string name="ext_media_unmounting_notification_message" msgid="4182843895023357756">"Neodoberajte"</string>
    <string name="ext_media_init_action" msgid="7952885510091978278">"Nastaviť"</string>
    <string name="ext_media_unmount_action" msgid="1121883233103278199">"Odpojiť"</string>
    <string name="ext_media_browse_action" msgid="8322172381028546087">"Preskúmať"</string>
    <string name="ext_media_missing_title" msgid="620980315821543904">"Chýba: <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_missing_message" msgid="5761133583368750174">"Opäť vložte toto zariadenie"</string>
    <string name="ext_media_move_specific_title" msgid="1471100343872375842">"Presúva sa aplikácia <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_title" msgid="1022809140035962662">"Presúvajú sa údaje"</string>
    <string name="ext_media_move_success_title" msgid="8575300932957954671">"Presun bol dokončený"</string>
    <string name="ext_media_move_success_message" msgid="4199002148206265426">"Údaje boli presunuté do úložiska <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_failure_title" msgid="7613189040358789908">"Presun údajov zlyhal"</string>
    <string name="ext_media_move_failure_message" msgid="1978096440816403360">"Údaje boli ponechané v pôvodnom umiestnení"</string>
    <string name="ext_media_status_removed" msgid="6576172423185918739">"Odstránené"</string>
    <string name="ext_media_status_unmounted" msgid="2551560878416417752">"Odpojené"</string>
    <string name="ext_media_status_checking" msgid="6193921557423194949">"Prebieha kontrola..."</string>
    <string name="ext_media_status_mounted" msgid="7253821726503179202">"Pripravené"</string>
    <string name="ext_media_status_mounted_ro" msgid="8020978752406021015">"Iba na čítanie"</string>
    <string name="ext_media_status_bad_removal" msgid="8395398567890329422">"Nebolo odstránené bezpečne"</string>
    <string name="ext_media_status_unmountable" msgid="805594039236667894">"Poškodené"</string>
    <string name="ext_media_status_unsupported" msgid="4691436711745681828">"Nepodporované"</string>
    <string name="ext_media_status_ejecting" msgid="5463887263101234174">"Odpája sa…"</string>
    <string name="ext_media_status_formatting" msgid="1085079556538644861">"Prebieha formátovanie..."</string>
    <string name="ext_media_status_missing" msgid="5638633895221670766">"Nie je zapojené"</string>
    <string name="activity_list_empty" msgid="1675388330786841066">"Nenašli sa žiadne zodpovedajúce aktivity."</string>
    <string name="permlab_route_media_output" msgid="6243022988998972085">"smerovanie výstupu médií"</string>
    <string name="permdesc_route_media_output" msgid="4932818749547244346">"Umožňuje aplikácii smerovať výstup médií do ďalších externých zariadení."</string>
    <string name="permlab_readInstallSessions" msgid="3713753067455750349">"čítanie inštalačných relácií"</string>
    <string name="permdesc_readInstallSessions" msgid="2049771699626019849">"Toto povolenie umožňuje aplikácii čítať relácie inštalácií a zobraziť tak podrobnosti o aktívnych inštaláciách balíkov."</string>
    <string name="permlab_requestInstallPackages" msgid="5782013576218172577">"odosielanie žiadostí o inštaláciu balíkov"</string>
    <string name="permdesc_requestInstallPackages" msgid="5740101072486783082">"Umožňuje aplikácii vyžiadať inštaláciu balíkov."</string>
    <string name="permlab_requestDeletePackages" msgid="1703686454657781242">"vyžiadať odstránenie balíkov"</string>
    <string name="permdesc_requestDeletePackages" msgid="3406172963097595270">"Umožňuje aplikácii vyžiadať odstránenie balíkov."</string>
    <string name="permlab_requestIgnoreBatteryOptimizations" msgid="8021256345643918264">"požiadať o ignorovanie optimalizácií výdrže batérie"</string>
    <string name="permdesc_requestIgnoreBatteryOptimizations" msgid="8359147856007447638">"Umožňuje aplikácii požiadať o povolenie ignorovať optimalizácie výdrže batérie pre danú aplikáciu."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="1311810005957319690">"Dvojitým klepnutím môžete ovládať priblíženie"</string>
    <string name="gadget_host_error_inflating" msgid="4882004314906466162">"Miniaplikáciu sa nepodarilo pridať."</string>
    <string name="ime_action_go" msgid="8320845651737369027">"Hľadať"</string>
    <string name="ime_action_search" msgid="658110271822807811">"Hľadať"</string>
    <string name="ime_action_send" msgid="2316166556349314424">"Odoslať"</string>
    <string name="ime_action_next" msgid="3138843904009813834">"Ďalej"</string>
    <string name="ime_action_done" msgid="8971516117910934605">"Hotovo"</string>
    <string name="ime_action_previous" msgid="1443550039250105948">"Predch."</string>
    <string name="ime_action_default" msgid="2840921885558045721">"Vykonať"</string>
    <string name="dial_number_using" msgid="5789176425167573586">"Vytočiť číslo\n <xliff:g id="NUMBER">%s</xliff:g>."</string>
    <string name="create_contact_using" msgid="4947405226788104538">"Vytvoriť kontakt\npre <xliff:g id="NUMBER">%s</xliff:g>."</string>
    <string name="grant_credentials_permission_message_header" msgid="2106103817937859662">"Nasledujúce aplikácie vyžadujú povolenie na prístup do vášho účtu (teraz aj v budúcnosti)."</string>
    <string name="grant_credentials_permission_message_footer" msgid="3125211343379376561">"Chcete túto žiadosť povoliť?"</string>
    <string name="grant_permissions_header_text" msgid="6874497408201826708">"Žiadosť o prístup"</string>
    <string name="allow" msgid="7225948811296386551">"Povoliť"</string>
    <string name="deny" msgid="2081879885755434506">"Zamietnuť"</string>
    <string name="permission_request_notification_title" msgid="6486759795926237907">"Vyžaduje sa povolenie"</string>
    <string name="permission_request_notification_with_subtitle" msgid="8530393139639560189">"Vyžaduje sa oprávnenie\npre účet <xliff:g id="ACCOUNT">%s</xliff:g>"</string>
    <string name="forward_intent_to_owner" msgid="1207197447013960896">"Túto aplikáciu používate mimo svojho pracovného profilu"</string>
    <string name="forward_intent_to_work" msgid="621480743856004612">"Túto aplikáciu používate vo svojom pracovnom profile"</string>
    <string name="input_method_binding_label" msgid="1283557179944992649">"Metóda vstupu"</string>
    <string name="sync_binding_label" msgid="3687969138375092423">"Synchronizovať"</string>
    <string name="accessibility_binding_label" msgid="4148120742096474641">"Dostupnosť"</string>
    <string name="wallpaper_binding_label" msgid="1240087844304687662">"Tapeta"</string>
    <string name="chooser_wallpaper" msgid="7873476199295190279">"Zmeniť tapetu"</string>
    <string name="notification_listener_binding_label" msgid="2014162835481906429">"Aplikácia na počúvanie upozornení"</string>
    <string name="vr_listener_binding_label" msgid="4316591939343607306">"Prijímač VR"</string>
    <string name="condition_provider_service_binding_label" msgid="1321343352906524564">"Poskytovateľ podmienky"</string>
    <string name="notification_ranker_binding_label" msgid="774540592299064747">"Služba na hodnotenie upozornení"</string>
    <string name="vpn_title" msgid="19615213552042827">"Sieť VPN je aktivovaná"</string>
    <string name="vpn_title_long" msgid="6400714798049252294">"Aplikáciu <xliff:g id="APP">%s</xliff:g> aktivovala sieť VPN"</string>
    <string name="vpn_text" msgid="1610714069627824309">"Kliknutím zobrazíte správu siete."</string>
    <string name="vpn_text_long" msgid="4907843483284977618">"Pripojené k relácii <xliff:g id="SESSION">%s</xliff:g>. Po klepnutí môžete sieť spravovať."</string>
    <string name="vpn_lockdown_connecting" msgid="6443438964440960745">"Pripájanie k vždy zapnutej sieti VPN…"</string>
    <string name="vpn_lockdown_connected" msgid="8202679674819213931">"Pripojenie k vždy zapnutej sieti VPN"</string>
    <string name="vpn_lockdown_disconnected" msgid="4532298952570796327">"Vždy zapnutá sieť VPN bola odpojená"</string>
    <string name="vpn_lockdown_error" msgid="6009249814034708175">"Chyba vždy zapnutej siete VPN"</string>
    <string name="vpn_lockdown_config" msgid="5099330695245008680">"Klepnutím prejdete do Nastavení"</string>
    <string name="upload_file" msgid="2897957172366730416">"Zvoliť súbor"</string>
    <string name="no_file_chosen" msgid="6363648562170759465">"Nie je vybratý žiadny súbor"</string>
    <string name="reset" msgid="2448168080964209908">"Obnoviť"</string>
    <string name="submit" msgid="1602335572089911941">"Odoslať"</string>
    <string name="car_mode_disable_notification_title" msgid="3164768212003864316">"Aktivovaný režim V aute"</string>
    <string name="car_mode_disable_notification_message" msgid="6301524980144350051">"Klepnutím ukončíte režim V aute."</string>
    <string name="tethered_notification_title" msgid="3146694234398202601">"Tethering alebo prístupový bod je aktívny"</string>
    <string name="tethered_notification_message" msgid="2113628520792055377">"Klepnutím prejdete na nastavenie."</string>
    <string name="back_button_label" msgid="2300470004503343439">"Späť"</string>
    <string name="next_button_label" msgid="1080555104677992408">"Ďalej"</string>
    <string name="skip_button_label" msgid="1275362299471631819">"Preskočiť"</string>
    <string name="no_matches" msgid="8129421908915840737">"Žiadne zhody"</string>
    <string name="find_on_page" msgid="1946799233822820384">"Vyhľadať na stránke"</string>
    <plurals name="matches_found" formatted="false" msgid="1210884353962081884">
      <item quantity="few"><xliff:g id="INDEX">%d</xliff:g> z <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="many"><xliff:g id="INDEX">%d</xliff:g> z <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="other"><xliff:g id="INDEX">%d</xliff:g> z <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="one">1 zápas</item>
    </plurals>
    <string name="action_mode_done" msgid="7217581640461922289">"Hotovo"</string>
    <string name="progress_erasing" product="nosdcard" msgid="4521573321524340058">"Prebieha vymazávanie ukladacieho priestoru USB..."</string>
    <string name="progress_erasing" product="default" msgid="6596988875507043042">"Prebieha vymazávanie SD karty..."</string>
    <string name="share" msgid="1778686618230011964">"Zdieľať"</string>
    <string name="find" msgid="4808270900322985960">"Nájsť"</string>
    <string name="websearch" msgid="4337157977400211589">"Hľadať na webe"</string>
    <string name="find_next" msgid="5742124618942193978">"Nájsť ďalšiu"</string>
    <string name="find_previous" msgid="2196723669388360506">"Nájsť predchádzajúcu"</string>
    <string name="gpsNotifTicker" msgid="5622683912616496172">"Žiadosť o informácie o polohe od používateľa <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="5446858717157416839">"Žiadosť o informácie o polohe"</string>
    <string name="gpsNotifMessage" msgid="1374718023224000702">"Žiadosť od používateľa <xliff:g id="NAME">%1$s</xliff:g> (<xliff:g id="SERVICE">%2$s</xliff:g>)"</string>
    <string name="gpsVerifYes" msgid="2346566072867213563">"Áno"</string>
    <string name="gpsVerifNo" msgid="1146564937346454865">"Nie"</string>
    <string name="sync_too_many_deletes" msgid="5296321850662746890">"Bol prekročený limit odstraňovania"</string>
    <string name="sync_too_many_deletes_desc" msgid="496551671008694245">"Počet odstránených položiek pre <xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g> účet <xliff:g id="ACCOUNT_NAME">%3$s</xliff:g> je: <xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g>. Čo chcete robiť?"</string>
    <string name="sync_really_delete" msgid="2572600103122596243">"Odstrániť položky"</string>
    <string name="sync_undo_deletes" msgid="2941317360600338602">"Vrátiť späť odstránenia"</string>
    <string name="sync_do_nothing" msgid="3743764740430821845">"Teraz nič nerobte"</string>
    <string name="choose_account_label" msgid="5655203089746423927">"Zvoliť účet"</string>
    <string name="add_account_label" msgid="2935267344849993553">"Pridať účet"</string>
    <string name="add_account_button_label" msgid="3611982894853435874">"Pridať účet"</string>
    <string name="number_picker_increment_button" msgid="2412072272832284313">"Zvýšiť"</string>
    <string name="number_picker_decrement_button" msgid="476050778386779067">"Znížiť"</string>
    <string name="number_picker_increment_scroll_mode" msgid="5259126567490114216">"<xliff:g id="VALUE">%s</xliff:g> – klepnúť a podržať."</string>
    <string name="number_picker_increment_scroll_action" msgid="9101473045891835490">"Ak chcete hodnotu zvýšiť, prejdite prstom nahor. Ak chcete hodnotu znížiť, prejdite prstom nadol."</string>
    <string name="time_picker_increment_minute_button" msgid="8865885114028614321">"Pridať minútu"</string>
    <string name="time_picker_decrement_minute_button" msgid="6246834937080684791">"Ubrať minútu"</string>
    <string name="time_picker_increment_hour_button" msgid="3652056055810223139">"Pridať hodinu"</string>
    <string name="time_picker_decrement_hour_button" msgid="1377479863429214792">"Ubrať hodinu"</string>
    <string name="time_picker_increment_set_pm_button" msgid="4147590696151230863">"Nastaviť čas popoludní"</string>
    <string name="time_picker_decrement_set_am_button" msgid="8302140353539486752">"Nastaviť čas AM"</string>
    <string name="date_picker_increment_month_button" msgid="5369998479067934110">"Pridať mesiac"</string>
    <string name="date_picker_decrement_month_button" msgid="1832698995541726019">"Ubrať mesiac"</string>
    <string name="date_picker_increment_day_button" msgid="7130465412308173903">"Pridať deň"</string>
    <string name="date_picker_decrement_day_button" msgid="4131881521818750031">"Ubrať deň"</string>
    <string name="date_picker_increment_year_button" msgid="6318697384310808899">"Pridať rok"</string>
    <string name="date_picker_decrement_year_button" msgid="4482021813491121717">"Ubrať rok"</string>
    <string name="date_picker_prev_month_button" msgid="2858244643992056505">"Predchádzajúci mesiac"</string>
    <string name="date_picker_next_month_button" msgid="5559507736887605055">"Nasledujúci mesiac"</string>
    <string name="keyboardview_keycode_alt" msgid="4856868820040051939">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="1203984017245783244">"Zrušiť"</string>
    <string name="keyboardview_keycode_delete" msgid="3337914833206635744">"Odstrániť"</string>
    <string name="keyboardview_keycode_done" msgid="1992571118466679775">"Hotovo"</string>
    <string name="keyboardview_keycode_mode_change" msgid="4547387741906537519">"Zmena režimu"</string>
    <string name="keyboardview_keycode_shift" msgid="2270748814315147690">"Shift"</string>
    <string name="keyboardview_keycode_enter" msgid="2985864015076059467">"Enter"</string>
    <string name="activitychooserview_choose_application" msgid="2125168057199941199">"Zvoľte aplikáciu"</string>
    <string name="activitychooserview_choose_application_error" msgid="8624618365481126668">"Aplikáciu <xliff:g id="APPLICATION_NAME">%s</xliff:g> nie je možné spustiť"</string>
    <string name="shareactionprovider_share_with" msgid="806688056141131819">"Zdieľať s"</string>
    <string name="shareactionprovider_share_with_application" msgid="5627411384638389738">"Zdieľať s aplikáciou <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="415975056159262248">"Posuvné tlačidlo. Dotknite sa a podržte."</string>
    <string name="description_target_unlock_tablet" msgid="3833195335629795055">"Posunom odomknúť."</string>
    <string name="action_bar_home_description" msgid="5293600496601490216">"Prejsť na plochu"</string>
    <string name="action_bar_up_description" msgid="2237496562952152589">"Prejsť na"</string>
    <string name="action_menu_overflow_description" msgid="2295659037509008453">"Viac možností"</string>
    <string name="action_bar_home_description_format" msgid="7965984360903693903">"%1$s, %2$s"</string>
    <string name="action_bar_home_subtitle_description_format" msgid="6985546530471780727">"%1$s, %2$s, %3$s"</string>
    <string name="storage_internal" msgid="3570990907910199483">"Interné zdieľané úložisko"</string>
    <string name="storage_sd_card" msgid="3282948861378286745">"SD karta"</string>
    <string name="storage_sd_card_label" msgid="6347111320774379257">"SD karta <xliff:g id="MANUFACTURER">%s</xliff:g>"</string>
    <string name="storage_usb_drive" msgid="6261899683292244209">"Disk USB"</string>
    <string name="storage_usb_drive_label" msgid="4501418548927759953">"Disk USB <xliff:g id="MANUFACTURER">%s</xliff:g>"</string>
    <string name="storage_usb" msgid="3017954059538517278">"Ukladací priestor USB"</string>
    <string name="extract_edit_menu_button" msgid="8940478730496610137">"Upraviť"</string>
    <string name="data_usage_warning_title" msgid="3620440638180218181">"Upozornenie na spotrebu dát"</string>
    <string name="data_usage_warning_body" msgid="6660692274311972007">"Klepnutím zobrazíte využitie a nastavenia."</string>
    <string name="data_usage_3g_limit_title" msgid="4361523876818447683">"Bol dosiahnutý limit 2G–3G"</string>
    <string name="data_usage_4g_limit_title" msgid="4609566827219442376">"Bol dosiahnutý limit 4G"</string>
    <string name="data_usage_mobile_limit_title" msgid="6561099244084267376">"Dosiahnutý limit mobilných dát"</string>
    <string name="data_usage_wifi_limit_title" msgid="5803363779034792676">"Bol dosiahnutý limit dát Wi‑Fi"</string>
    <string name="data_usage_limit_body" msgid="291731708279614081">"Údaje pre zbytok cyklu pozastavené"</string>
    <string name="data_usage_3g_limit_snoozed_title" msgid="7026739121138005231">"2G, 3G dátový limit prekročený"</string>
    <string name="data_usage_4g_limit_snoozed_title" msgid="1106562779311209039">"Dátový limit 4G bol prekročený"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="279240572165412168">"Prekroč. limit pre mobil. dáta"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="8743856006384825974">"Dát. limit Wi‑Fi bol prekročený"</string>
    <string name="data_usage_limit_snoozed_body" msgid="7035490278298441767">"<xliff:g id="SIZE">%s</xliff:g> nad stanovenou hranicou."</string>
    <string name="data_usage_restricted_title" msgid="5965157361036321914">"Dátové prenosy obmedzené"</string>
    <string name="data_usage_restricted_body" msgid="469866376337242726">"Klepnutím odstránite obmedzenie."</string>
    <string name="ssl_certificate" msgid="6510040486049237639">"Certifikát zabezpečenia"</string>
    <string name="ssl_certificate_is_valid" msgid="6825263250774569373">"Certifikát je platný."</string>
    <string name="issued_to" msgid="454239480274921032">"Vydané pre:"</string>
    <string name="common_name" msgid="2233209299434172646">"Bežný názov:"</string>
    <string name="org_name" msgid="6973561190762085236">"Organizácia:"</string>
    <string name="org_unit" msgid="7265981890422070383">"Organizačná jednotka:"</string>
    <string name="issued_by" msgid="2647584988057481566">"Vydal:"</string>
    <string name="validity_period" msgid="8818886137545983110">"Platnosť:"</string>
    <string name="issued_on" msgid="5895017404361397232">"Dátum vydania:"</string>
    <string name="expires_on" msgid="3676242949915959821">"Platnosť vyprší:"</string>
    <string name="serial_number" msgid="758814067660862493">"Sériové číslo:"</string>
    <string name="fingerprints" msgid="4516019619850763049">"Digitálne odtlačky:"</string>
    <string name="sha256_fingerprint" msgid="4391271286477279263">"Digitálny odtlačok SHA-256:"</string>
    <string name="sha1_fingerprint" msgid="7930330235269404581">"Digitálny odtlačok SHA-1:"</string>
    <string name="activity_chooser_view_see_all" msgid="4292569383976636200">"Zobraziť všetky"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="4710013864974040615">"Vybrať aktivitu"</string>
    <string name="share_action_provider_share_with" msgid="5247684435979149216">"Zdieľať s"</string>
    <string name="sending" msgid="3245653681008218030">"Odosielanie..."</string>
    <string name="launchBrowserDefault" msgid="2057951947297614725">"Spustiť prehliadač?"</string>
    <string name="SetupCallDefault" msgid="5834948469253758575">"Prijať hovor?"</string>
    <string name="activity_resolver_use_always" msgid="8017770747801494933">"Vždy"</string>
    <string name="activity_resolver_use_once" msgid="2404644797149173758">"Len raz"</string>
    <string name="activity_resolver_work_profiles_support" msgid="185598180676883455">"Spúšťač %1$s nepodporuje pracovné profily"</string>
    <string name="default_audio_route_name" product="tablet" msgid="4617053898167127471">"Tablet"</string>
    <string name="default_audio_route_name" product="tv" msgid="9158088547603019321">"Televízor"</string>
    <string name="default_audio_route_name" product="default" msgid="4239291273420140123">"Telefón"</string>
    <string name="default_audio_route_name_headphones" msgid="8119971843803439110">"Slúchadlá"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="6240602982276591864">"Reproduktory doku"</string>
    <string name="default_media_route_name_hdmi" msgid="2450970399023478055">"HDMI"</string>
    <string name="default_audio_route_category_name" msgid="3722811174003886946">"Systém"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="8575624030406771015">"Bluetooth audio"</string>
    <string name="wireless_display_route_description" msgid="9070346425023979651">"Bezdrôtové zobrazenie"</string>
    <string name="media_route_button_content_description" msgid="591703006349356016">"Prenášať"</string>
    <string name="media_route_chooser_title" msgid="1751618554539087622">"Pripojenie k zariadeniu"</string>
    <string name="media_route_chooser_title_for_remote_display" msgid="3395541745872017583">"Prenos obrazovky do zariadenia"</string>
    <string name="media_route_chooser_searching" msgid="4776236202610828706">"Prebieha vyhľadávanie zariadení…"</string>
    <string name="media_route_chooser_extended_settings" msgid="87015534236701604">"Nastavenia"</string>
    <string name="media_route_controller_disconnect" msgid="8966120286374158649">"Odpojiť"</string>
    <string name="media_route_status_scanning" msgid="7279908761758293783">"Prebieha vyhľadávanie..."</string>
    <string name="media_route_status_connecting" msgid="6422571716007825440">"Prebieha pripájanie…"</string>
    <string name="media_route_status_available" msgid="6983258067194649391">"K dispozícii"</string>
    <string name="media_route_status_not_available" msgid="6739899962681886401">"Nie je k dispozícii"</string>
    <string name="media_route_status_in_use" msgid="4533786031090198063">"Používa sa"</string>
    <string name="display_manager_built_in_display_name" msgid="2583134294292563941">"Vstavaná obrazovka"</string>
    <string name="display_manager_hdmi_display_name" msgid="1555264559227470109">"Obrazovka HDMI"</string>
    <string name="display_manager_overlay_display_name" msgid="5142365982271620716">"Prekrytie č. <xliff:g id="ID">%1$d</xliff:g>"</string>
    <string name="display_manager_overlay_display_title" msgid="652124517672257172">"<xliff:g id="NAME">%1$s</xliff:g>: <xliff:g id="WIDTH">%2$d</xliff:g> x <xliff:g id="HEIGHT">%3$d</xliff:g>, <xliff:g id="DPI">%4$d</xliff:g> dpi"</string>
    <string name="display_manager_overlay_display_secure_suffix" msgid="6022119702628572080">", zabezpečené"</string>
    <string name="kg_forgot_pattern_button_text" msgid="8852021467868220608">"Nepamätám si vzor"</string>
    <string name="kg_wrong_pattern" msgid="1850806070801358830">"Nesprávny vzor"</string>
    <string name="kg_wrong_password" msgid="2333281762128113157">"Nesprávne heslo"</string>
    <string name="kg_wrong_pin" msgid="1131306510833563801">"Nesprávny kód PIN"</string>
    <string name="kg_too_many_failed_attempts_countdown" msgid="6358110221603297548">"Skúste to znova o <xliff:g id="NUMBER">%1$d</xliff:g> s."</string>
    <string name="kg_pattern_instructions" msgid="398978611683075868">"Nakreslite svoj vzor"</string>
    <string name="kg_sim_pin_instructions" msgid="2319508550934557331">"Zadajte kód PIN SIM karty"</string>
    <string name="kg_pin_instructions" msgid="2377242233495111557">"Zadajte kód PIN"</string>
    <string name="kg_password_instructions" msgid="5753646556186936819">"Zadajte heslo"</string>
    <string name="kg_puk_enter_puk_hint" msgid="453227143861735537">"SIM karta je teraz zakázaná. Ak chcete pokračovať, zadajte kód PUK. Podrobné informácie získate od operátora."</string>
    <string name="kg_puk_enter_pin_hint" msgid="7871604527429602024">"Zadajte požadovaný kód PIN"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="325676184762529976">"Potvrďte požadovaný kód PIN"</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8950398016976865762">"Prebieha odomykanie SIM karty..."</string>
    <string name="kg_password_wrong_pin_code" msgid="1139324887413846912">"Nesprávny kód PIN."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="8795159358110620001">"Zadajte kód PIN s dĺžkou 4 až 8 číslic."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="6025069204539532000">"Kód PUK musí obsahovať 8 číslic."</string>
    <string name="kg_invalid_puk" msgid="3638289409676051243">"Znova zadajte správny kód PUK. Opakované pokusy zakážu SIM kartu natrvalo."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="7003469261464593516">"Kódy PIN sa nezhodujú"</string>
    <string name="kg_login_too_many_attempts" msgid="6486842094005698475">"Príliš veľa pokusov o nakreslenie vzoru"</string>
    <string name="kg_login_instructions" msgid="1100551261265506448">"Ak chcete telefón odomknúť, prihláste sa pomocou svojho účtu Google."</string>
    <string name="kg_login_username_hint" msgid="5718534272070920364">"Používateľské meno (e-mail)"</string>
    <string name="kg_login_password_hint" msgid="9057289103827298549">"Heslo"</string>
    <string name="kg_login_submit_button" msgid="5355904582674054702">"Prihlásiť sa"</string>
    <string name="kg_login_invalid_input" msgid="5754664119319872197">"Neplatné používateľské meno alebo heslo."</string>
    <string name="kg_login_account_recovery_hint" msgid="5690709132841752974">"Zabudli ste svoje používateľské meno alebo heslo?\n Navštívte stránky "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="kg_login_checking_password" msgid="1052685197710252395">"Prebieha kontrola účtu..."</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="8276745642049502550">"<xliff:g id="NUMBER_0">%1$d</xliff:g>-krát ste zadali nesprávny kód PIN. \n\nSkúste to znova o <xliff:g id="NUMBER_1">%2$d</xliff:g> s."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="7813713389422226531">"<xliff:g id="NUMBER_0">%1$d</xliff:g>-krát ste zadali nesprávne heslo. \n\nSkúste to znova o <xliff:g id="NUMBER_1">%2$d</xliff:g> s."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="74089475965050805">"<xliff:g id="NUMBER_0">%1$d</xliff:g>-krát ste použili nesprávny bezpečnostný vzor. \n\nSkúste to znova o <xliff:g id="NUMBER_1">%2$d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="1575557200627128949">"Tablet ste sa pokúsili odomknúť nesprávnym spôsobom <xliff:g id="NUMBER_0">%1$d</xliff:g>-krát. Po <xliff:g id="NUMBER_1">%2$d</xliff:g> ďalších neúspešných pokusoch sa v tablete obnovia predvolené výrobné nastavenia a všetky používateľské údaje budú stratené."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tv" msgid="5621231220154419413">"Televízor ste sa pokúsili nesprávne odomknúť <xliff:g id="NUMBER_0">%1$d</xliff:g>-krát. Po ďalších neúspešných pokusoch (počet: <xliff:g id="NUMBER_1">%2$d</xliff:g>) sa obnovia výrobné nastavenia televízora a prídete o všetky údaje používateľa."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="4051015943038199910">"Telefón ste sa pokúsili odomknúť nesprávnym spôsobom <xliff:g id="NUMBER_0">%1$d</xliff:g>-krát. Po <xliff:g id="NUMBER_1">%2$d</xliff:g> ďalších neúspešných pokusoch sa v telefóne obnovia predvolené výrobné nastavenia a všetky používateľské údaje budú stratené."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="2072996269148483637">"Tablet ste sa pokúsili odomknúť nesprávnym spôsobom <xliff:g id="NUMBER">%d</xliff:g>-krát. V tablete sa teraz obnovia predvolené výrobné nastavenia."</string>
    <string name="kg_failed_attempts_now_wiping" product="tv" msgid="4987878286750741463">"Televízor ste sa pokúsili nesprávne odomknúť <xliff:g id="NUMBER">%d</xliff:g>-krát. Teraz sa v ňom obnovia výrobné nastavenia."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="4817627474419471518">"Telefón ste sa pokúsili odomknúť nesprávnym spôsobom <xliff:g id="NUMBER">%d</xliff:g>-krát. V telefóne sa teraz obnovia predvolené výrobné nastavenia."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="3253575572118914370">"<xliff:g id="NUMBER_0">%1$d</xliff:g>-krát ste nesprávne nakreslili svoj bezpečnostný vzor. Po ďalších <xliff:g id="NUMBER_1">%2$d</xliff:g> neúspešných pokusoch sa zobrazí výzva na odomknutie tabletu pomocou e-mailového účtu.\n\n Skúste to znova o <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tv" msgid="4224651132862313471">"Vzor na odomknutie ste nakreslili nesprávne <xliff:g id="NUMBER_0">%1$d</xliff:g>-krát. Po ďalších neúspešných pokusoch (počet: <xliff:g id="NUMBER_1">%2$d</xliff:g>) sa zobrazí výzva na odomknutie televízora pomocou e-mailového účtu.\n\n Skúste to znova o <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="1437638152015574839">"<xliff:g id="NUMBER_0">%1$d</xliff:g>-krát ste nesprávne nakreslili svoj bezpečnostný vzor. Po <xliff:g id="NUMBER_1">%2$d</xliff:g> ďalších neúspešných pokusoch sa zobrazí výzva na odomknutie telefónu pomocou e-mailového účtu.\n\n Skúste to znova o <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="kg_text_message_separator" product="default" msgid="4160700433287233771">" — "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="7899202978204438708">"Odstrániť"</string>
    <string name="safe_media_volume_warning" product="default" msgid="2276318909314492312">"Zvýšiť hlasitosť nad odporúčanú úroveň?\n\nDlhodobé počúvanie pri vysokej hlasitosti môže poškodiť váš sluch."</string>
    <string name="accessibility_shortcut_warning_dialog_title" msgid="8404780875025725199">"Použiť skratku dostupnosti?"</string>
    <string name="accessibility_shortcut_toogle_warning" msgid="7256507885737444807">"Keď je skratka zapnutá, stlačením obidvoch tlačidiel hlasitosti na tri sekundy spustíte funkciu dostupnosti.\n\n Aktuálna funkcia dostupnosti:\n <xliff:g id="SERVICE_NAME">%1$s</xliff:g>\n\n Funkciu môžete zmeniť v časti Nastavenia &gt; Dostupnosť."</string>
    <string name="disable_accessibility_shortcut" msgid="627625354248453445">"Vypnúť skratku"</string>
    <string name="leave_accessibility_shortcut_on" msgid="7653111894438512680">"Použiť skratku"</string>
    <string name="accessibility_shortcut_enabling_service" msgid="7771852911861522636">"Skratka dostupnosti zapla službu <xliff:g id="SERVICE_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_disabling_service" msgid="2747243438223109821">"Skratka dostupnosti vypla službu <xliff:g id="SERVICE_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_button_prompt_text" msgid="4234556536456854251">"Klepnutím na tlačidlo dostupnosti vyberte požadovanú funkciu:"</string>
    <string name="accessibility_button_instructional_text" msgid="6942300463612999993">"Ak chcete zmeniť funkcie, klepnite na tlačidlo dostupnosti a podržte ho"</string>
    <string name="accessibility_magnification_chooser_text" msgid="1227146738764986237">"Priblíženie"</string>
    <string name="user_switched" msgid="3768006783166984410">"Aktuálny používateľ je <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="user_switching_message" msgid="2871009331809089783">"Prepína sa na účet <xliff:g id="NAME">%1$s</xliff:g>…"</string>
    <string name="user_logging_out_message" msgid="8939524935808875155">"Prebieha odhlásenie používateľa <xliff:g id="NAME">%1$s</xliff:g>…"</string>
    <string name="owner_name" msgid="2716755460376028154">"Vlastník"</string>
    <string name="error_message_title" msgid="4510373083082500195">"Chyba"</string>
    <string name="error_message_change_not_allowed" msgid="1238035947357923497">"Správca túto zmenu zakázal"</string>
    <string name="app_not_found" msgid="3429141853498927379">"Aplikácia potrebná na spracovanie tejto akcie sa nenašla"</string>
    <string name="revoke" msgid="5404479185228271586">"Odvolať"</string>
    <string name="mediasize_iso_a0" msgid="1994474252931294172">"ISO A0"</string>
    <string name="mediasize_iso_a1" msgid="3333060421529791786">"ISO A1"</string>
    <string name="mediasize_iso_a2" msgid="3097535991925798280">"ISO A2"</string>
    <string name="mediasize_iso_a3" msgid="3023213259314236123">"ISO A3"</string>
    <string name="mediasize_iso_a4" msgid="231745325296873764">"ISO A4"</string>
    <string name="mediasize_iso_a5" msgid="3484327407340865411">"ISO A5"</string>
    <string name="mediasize_iso_a6" msgid="4861908487129577530">"ISO A6"</string>
    <string name="mediasize_iso_a7" msgid="5890208588072936130">"ISO A7"</string>
    <string name="mediasize_iso_a8" msgid="4319425041085816612">"ISO A8"</string>
    <string name="mediasize_iso_a9" msgid="4882220529506432008">"ISO A9"</string>
    <string name="mediasize_iso_a10" msgid="2382866026365359391">"ISO A10"</string>
    <string name="mediasize_iso_b0" msgid="3651827147402009675">"ISO B0"</string>
    <string name="mediasize_iso_b1" msgid="6072859628278739957">"ISO B1"</string>
    <string name="mediasize_iso_b2" msgid="1348731852150380378">"ISO B2"</string>
    <string name="mediasize_iso_b3" msgid="2612510181259261379">"ISO B3"</string>
    <string name="mediasize_iso_b4" msgid="695151378838115434">"ISO B4"</string>
    <string name="mediasize_iso_b5" msgid="4863754285582212487">"ISO B5"</string>
    <string name="mediasize_iso_b6" msgid="5305816292139647241">"ISO B6"</string>
    <string name="mediasize_iso_b7" msgid="531673542602786624">"ISO B7"</string>
    <string name="mediasize_iso_b8" msgid="9164474595708850034">"ISO B8"</string>
    <string name="mediasize_iso_b9" msgid="282102976764774160">"ISO B9"</string>
    <string name="mediasize_iso_b10" msgid="4517141714407898976">"ISO B10"</string>
    <string name="mediasize_iso_c0" msgid="3103521357901591100">"ISO C0"</string>
    <string name="mediasize_iso_c1" msgid="1231954105985048595">"ISO C1"</string>
    <string name="mediasize_iso_c2" msgid="927702816980087462">"ISO C2"</string>
    <string name="mediasize_iso_c3" msgid="835154173518304159">"ISO C3"</string>
    <string name="mediasize_iso_c4" msgid="5095951985108194011">"ISO C4"</string>
    <string name="mediasize_iso_c5" msgid="1985397450332305739">"ISO C5"</string>
    <string name="mediasize_iso_c6" msgid="8147421924174693013">"ISO C6"</string>
    <string name="mediasize_iso_c7" msgid="8993994925276122950">"ISO C7"</string>
    <string name="mediasize_iso_c8" msgid="6871178104139598957">"ISO C8"</string>
    <string name="mediasize_iso_c9" msgid="7983532635227561362">"ISO C9"</string>
    <string name="mediasize_iso_c10" msgid="5040764293406765584">"ISO C10"</string>
    <string name="mediasize_na_letter" msgid="2841414839888344296">"List"</string>
    <string name="mediasize_na_gvrnmt_letter" msgid="5295836838862962809">"Úradný list"</string>
    <string name="mediasize_na_legal" msgid="8621364037680465666">"Legal"</string>
    <string name="mediasize_na_junior_legal" msgid="3309324162155085904">"Junior Legal"</string>
    <string name="mediasize_na_ledger" msgid="5567030340509075333">"Ledger"</string>
    <string name="mediasize_na_tabloid" msgid="4571735038501661757">"Tabloid"</string>
    <string name="mediasize_na_index_3x5" msgid="5182901917818625126">"Index Card 3x5"</string>
    <string name="mediasize_na_index_4x6" msgid="7687620625422312396">"Index Card 4x6"</string>
    <string name="mediasize_na_index_5x8" msgid="8834215284646872800">"Index Card 5x8"</string>
    <string name="mediasize_na_monarch" msgid="213639906956550754">"Monarch"</string>
    <string name="mediasize_na_quarto" msgid="835778493593023223">"Quarto"</string>
    <string name="mediasize_na_foolscap" msgid="1573911237983677138">"Foolscap"</string>
    <string name="mediasize_chinese_roc_8k" msgid="3626855847189438896">"ROC 8K"</string>
    <string name="mediasize_chinese_roc_16k" msgid="9182191577022943355">"ROC 16K"</string>
    <string name="mediasize_chinese_prc_1" msgid="4793232644980170500">"PRC 1"</string>
    <string name="mediasize_chinese_prc_2" msgid="5404109730975720670">"PRC 2"</string>
    <string name="mediasize_chinese_prc_3" msgid="1335092253339363526">"PRC 3"</string>
    <string name="mediasize_chinese_prc_4" msgid="9167997800486569834">"PRC 4"</string>
    <string name="mediasize_chinese_prc_5" msgid="845875168823541497">"PRC 5"</string>
    <string name="mediasize_chinese_prc_6" msgid="3220325667692648789">"PRC 6"</string>
    <string name="mediasize_chinese_prc_7" msgid="1776792138507038527">"PRC 7"</string>
    <string name="mediasize_chinese_prc_8" msgid="1417176642687456692">"PRC 8"</string>
    <string name="mediasize_chinese_prc_9" msgid="4785983473123798365">"PRC 9"</string>
    <string name="mediasize_chinese_prc_10" msgid="7847982299391851899">"PRC 10"</string>
    <string name="mediasize_chinese_prc_16k" msgid="262793383539980677">"PRC 16K"</string>
    <string name="mediasize_chinese_om_pa_kai" msgid="5256815579447959814">"Pa Kai"</string>
    <string name="mediasize_chinese_om_dai_pa_kai" msgid="7336412963441354407">"Dai Pa Kai"</string>
    <string name="mediasize_chinese_om_jurro_ku_kai" msgid="6324465444100490742">"Jurro Ku Kai"</string>
    <string name="mediasize_japanese_jis_b10" msgid="1787262845627694376">"JIS B10"</string>
    <string name="mediasize_japanese_jis_b9" msgid="3336035783663287470">"JIS B9"</string>
    <string name="mediasize_japanese_jis_b8" msgid="6195398299104345731">"JIS B8"</string>
    <string name="mediasize_japanese_jis_b7" msgid="1674621886902828884">"JIS B7"</string>
    <string name="mediasize_japanese_jis_b6" msgid="4170576286062657435">"JIS B6"</string>
    <string name="mediasize_japanese_jis_b5" msgid="4899297958100032533">"JIS B5"</string>
    <string name="mediasize_japanese_jis_b4" msgid="4213158129126666847">"JIS B4"</string>
    <string name="mediasize_japanese_jis_b3" msgid="8513715307410310696">"JIS B3"</string>
    <string name="mediasize_japanese_jis_b2" msgid="4777690211897131190">"JIS B2"</string>
    <string name="mediasize_japanese_jis_b1" msgid="4608142385457034603">"JIS B1"</string>
    <string name="mediasize_japanese_jis_b0" msgid="7587108366572243991">"JIS B0"</string>
    <string name="mediasize_japanese_jis_exec" msgid="5244075432263649068">"JIS Exec"</string>
    <string name="mediasize_japanese_chou4" msgid="4941652015032631361">"Chou4"</string>
    <string name="mediasize_japanese_chou3" msgid="6387319169263957010">"Chou3"</string>
    <string name="mediasize_japanese_chou2" msgid="1299112025415343982">"Chou2"</string>
    <string name="mediasize_japanese_hagaki" msgid="8070115620644254565">"Hagaki"</string>
    <string name="mediasize_japanese_oufuku" msgid="6049065587307896564">"Oufuku"</string>
    <string name="mediasize_japanese_kahu" msgid="6872696027560065173">"Kahu"</string>
    <string name="mediasize_japanese_kaku2" msgid="2359077233775455405">"Kaku2"</string>
    <string name="mediasize_japanese_you4" msgid="2091777168747058008">"You4"</string>
    <string name="mediasize_unknown_portrait" msgid="3088043641616409762">"Neznáma veľkosť papiera na výšku"</string>
    <string name="mediasize_unknown_landscape" msgid="4876995327029361552">"Neznáma veľkosť papiera na šírku"</string>
    <string name="write_fail_reason_cancelled" msgid="7091258378121627624">"Zrušené"</string>
    <string name="write_fail_reason_cannot_write" msgid="8132505417935337724">"Pri zapisovaní obsahu došlo ku chybe"</string>
    <string name="reason_unknown" msgid="6048913880184628119">"neznáme"</string>
    <string name="reason_service_unavailable" msgid="7824008732243903268">"Tlačová služba nie je povolená"</string>
    <string name="print_service_installed_title" msgid="2246317169444081628">"Nainštalovaná služba: <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="print_service_installed_message" msgid="5897362931070459152">"Povoľte klepnutím"</string>
    <string name="restr_pin_enter_admin_pin" msgid="8641662909467236832">"Zadanie kódu PIN správcu"</string>
    <string name="restr_pin_enter_pin" msgid="3395953421368476103">"Zadajte kód PIN"</string>
    <string name="restr_pin_incorrect" msgid="8571512003955077924">"Nesprávny kód"</string>
    <string name="restr_pin_enter_old_pin" msgid="1462206225512910757">"Aktuálny kód PIN"</string>
    <string name="restr_pin_enter_new_pin" msgid="5959606691619959184">"Nový kód PIN"</string>
    <string name="restr_pin_confirm_pin" msgid="8501523829633146239">"Potvrďte nový kód PIN"</string>
    <string name="restr_pin_create_pin" msgid="8017600000263450337">"Vytvoriť kód PIN pre obmedzenia upravovania"</string>
    <string name="restr_pin_error_doesnt_match" msgid="2224214190906994548">"Kódy PIN sa nezhodujú. Skúste to znova."</string>
    <string name="restr_pin_error_too_short" msgid="8173982756265777792">"Kód PIN je príliš krátky. Musí mať minimálne 4 číslice."</string>
    <plurals name="restr_pin_countdown" formatted="false" msgid="9061246974881224688">
      <item quantity="few">Skúste to znova o <xliff:g id="COUNT">%d</xliff:g> sekundy</item>
      <item quantity="many">Skúste to znova o <xliff:g id="COUNT">%d</xliff:g> sekundy</item>
      <item quantity="other">Skúste to znova o <xliff:g id="COUNT">%d</xliff:g> sekúnd</item>
      <item quantity="one">Skúste to znova o 1 sekundu</item>
    </plurals>
    <string name="restr_pin_try_later" msgid="973144472490532377">"Skúste to znova neskôr"</string>
    <string name="immersive_cling_title" msgid="8394201622932303336">"Zobrazenie na celú obrazovku"</string>
    <string name="immersive_cling_description" msgid="3482371193207536040">"Ukončíte prejdením prstom zhora nadol."</string>
    <string name="immersive_cling_positive" msgid="5016839404568297683">"Dobre"</string>
    <string name="done_label" msgid="2093726099505892398">"Hotovo"</string>
    <string name="hour_picker_description" msgid="6698199186859736512">"Kruhový posúvač hodín"</string>
    <string name="minute_picker_description" msgid="8606010966873791190">"Kruhový posúvač minút"</string>
    <string name="select_hours" msgid="6043079511766008245">"Vyberte hodiny"</string>
    <string name="select_minutes" msgid="3974345615920336087">"Vyberte minúty"</string>
    <string name="select_day" msgid="7774759604701773332">"Vyberte mesiac a deň"</string>
    <string name="select_year" msgid="7952052866994196170">"Vyberte rok"</string>
    <string name="deleted_key" msgid="7659477886625566590">"Číslo <xliff:g id="KEY">%1$s</xliff:g> bolo odstránené"</string>
    <string name="managed_profile_label_badge" msgid="2355652472854327647">"Práca – <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="managed_profile_label_badge_2" msgid="5048136430082124036">"2. <xliff:g id="LABEL">%1$s</xliff:g> do práce"</string>
    <string name="managed_profile_label_badge_3" msgid="2808305070321719040">"3. <xliff:g id="LABEL">%1$s</xliff:g> do práce"</string>
    <string name="lock_to_app_toast" msgid="6820571533009838261">"Ak chcete odopnúť túto obrazovku, klepnite na tlačidlá Späť a Prehľad a podržte ich"</string>
    <string name="lock_to_app_toast_locked" msgid="7849470948648628704">"Táto aplikácia sa nedá odopnúť"</string>
    <string name="lock_to_app_start" msgid="6643342070839862795">"Obrazovka bola pripnutá"</string>
    <string name="lock_to_app_exit" msgid="8598219838213787430">"Obrazovka bola uvoľnená"</string>
    <string name="lock_to_app_unlock_pin" msgid="2552556656504331634">"Pred uvoľnením požiadať o číslo PIN"</string>
    <string name="lock_to_app_unlock_pattern" msgid="4182192144797225137">"Pred uvoľnením požiadať o bezpečnostný vzor"</string>
    <string name="lock_to_app_unlock_password" msgid="6380979775916974414">"Pred uvoľnením požiadať o heslo"</string>
    <string name="package_installed_device_owner" msgid="6875717669960212648">"Nainštaloval správca"</string>
    <string name="package_updated_device_owner" msgid="1847154566357862089">"Aktualizoval správca"</string>
    <string name="package_deleted_device_owner" msgid="2307122077550236438">"Odstránil správca"</string>
    <string name="battery_saver_description" msgid="1960431123816253034">"Šetrič batérie zníži výkonnosť zariadenia a obmedzí vibrácie, služby určovania polohy a dátové prenosy na pozadí, aby predĺžil výdrž batérie. Pošta, čet a ďalšie aplikácie, ktoré sa spoliehajú na synchronizáciu, sa možno nebudú aktualizovať, dokiaľ ich neotvoríte.\n\nPri nabíjaní zariadenia sa šetrič batérie automaticky vypne."</string>
    <string name="data_saver_description" msgid="6015391409098303235">"Šetrič dát bráni niektorým aplikáciám odosielať alebo prijímať dáta na pozadí s cieľom znížiť spotrebu dát. Aplikácia, ktorú momentálne používate, môže prenášať dáta, ale môže to robiť menej často. Znamená to napríklad, že sa nezobrazia obrázky, kým na ne neklepnete."</string>
    <string name="data_saver_enable_title" msgid="4674073932722787417">"Chcete zapnúť šetrič dát?"</string>
    <string name="data_saver_enable_button" msgid="7147735965247211818">"Zapnúť"</string>
    <plurals name="zen_mode_duration_minutes_summary" formatted="false" msgid="4367877408072000848">
      <item quantity="few">%1$d minúty (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">%1$d minúty (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d minút (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">1 minútu (do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_summary_short" formatted="false" msgid="6830154222366042597">
      <item quantity="few">Na %1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">Na %1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Na %1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Na 1 min (do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary" formatted="false" msgid="8152974162096743862">
      <item quantity="few">%1$d hodiny (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">%1$d hodiny (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d hodín (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">1 hodinu (do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary_short" formatted="false" msgid="4787552595253082371">
      <item quantity="few">Na %1$d h (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">Na %1$d h (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Na %1$d h (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Na 1 h (do <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes" formatted="false" msgid="5127407202506485571">
      <item quantity="few">%d minúty</item>
      <item quantity="many">%d minúty</item>
      <item quantity="other">%d minút</item>
      <item quantity="one">1 minútu</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_short" formatted="false" msgid="2199350154433426128">
      <item quantity="few">Na %d min</item>
      <item quantity="many">Na %d min</item>
      <item quantity="other">Na %d min</item>
      <item quantity="one">Na 1 min</item>
    </plurals>
    <plurals name="zen_mode_duration_hours" formatted="false" msgid="3938821308277433854">
      <item quantity="few">%d hodiny</item>
      <item quantity="many">%d hodiny</item>
      <item quantity="other">%d hodín</item>
      <item quantity="one">1 hodinu</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_short" formatted="false" msgid="6748277774662434217">
      <item quantity="few">Na %d h</item>
      <item quantity="many">Na %d h</item>
      <item quantity="other">Na %d h</item>
      <item quantity="one">Na 1 h</item>
    </plurals>
    <string name="zen_mode_until" msgid="7336308492289875088">"Do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_alarm" msgid="9128205721301330797">"Do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g> (ďalší budík)"</string>
    <string name="zen_mode_forever" msgid="1916263162129197274">"Dokiaľ nevypnete režim Nerušiť"</string>
    <string name="zen_mode_forever_dnd" msgid="3792132696572189081">"Dokiaľ nevypnete režim Nerušiť"</string>
    <string name="zen_mode_rule_name_combination" msgid="191109939968076477">"<xliff:g id="FIRST">%1$s</xliff:g> / <xliff:g id="REST">%2$s</xliff:g>"</string>
    <string name="toolbar_collapse_description" msgid="2821479483960330739">"Zbaliť"</string>
    <string name="zen_mode_feature_name" msgid="5254089399895895004">"Nerušiť"</string>
    <string name="zen_mode_downtime_feature_name" msgid="2626974636779860146">"Doba pokoja"</string>
    <string name="zen_mode_default_weeknights_name" msgid="3081318299464998143">"Noc pracovného dňa"</string>
    <string name="zen_mode_default_weekends_name" msgid="2786495801019345244">"Víkend"</string>
    <string name="zen_mode_default_events_name" msgid="8158334939013085363">"Udalosť"</string>
    <string name="muted_by" msgid="6147073845094180001">"Stlmené aplikáciou <xliff:g id="THIRD_PARTY">%1$s</xliff:g>"</string>
    <string name="system_error_wipe_data" msgid="6608165524785354962">"Vo vašom zariadení došlo k internému problému. Môže byť nestabilné, kým neobnovíte jeho výrobné nastavenia."</string>
    <string name="system_error_manufacturer" msgid="8086872414744210668">"Vo vašom zariadení došlo k internému problému. Ak chcete získať podrobné informácie, obráťte sa na jeho výrobcu."</string>
    <string name="stk_cc_ussd_to_dial" msgid="5202342984749947872">"Žiadosť USSD bola upravená na žiadosť DIAL."</string>
    <string name="stk_cc_ussd_to_ss" msgid="2345360594181405482">"Žiadosť USSD bola upravená na žiadosť SS."</string>
    <string name="stk_cc_ussd_to_ussd" msgid="7466087659967191653">"Žiadosť USSD bola upravená na novú žiadosť USSD."</string>
    <string name="stk_cc_ss_to_dial" msgid="2151304435775557162">"Žiadosť SS bola upravená na žiadosť DIAL."</string>
    <string name="stk_cc_ss_to_ussd" msgid="3951862188105305589">"Žiadosť SS bola upravená na žiadosť USSD."</string>
    <string name="stk_cc_ss_to_ss" msgid="5470768854991452695">"Žiadosť SS bola upravená na novú žiadosť SS."</string>
    <string name="notification_work_profile_content_description" msgid="4600554564103770764">"Pracovný profil"</string>
    <string name="expand_button_content_description_collapsed" msgid="3609784019345534652">"Rozbaliť"</string>
    <string name="expand_button_content_description_expanded" msgid="8520652707158554895">"Zbaliť"</string>
    <string name="expand_action_accessibility" msgid="5307730695723718254">"prepnúť rozbalenie"</string>
    <string name="usb_midi_peripheral_name" msgid="7221113987741003817">"Port USB pre periférne zariadenia s Androidom"</string>
    <string name="usb_midi_peripheral_manufacturer_name" msgid="7176526170008970168">"Android"</string>
    <string name="usb_midi_peripheral_product_name" msgid="4971827859165280403">"Port USB pre periférne zariadenia"</string>
    <string name="floating_toolbar_open_overflow_description" msgid="4797287862999444631">"Ďalšie možnosti"</string>
    <string name="floating_toolbar_close_overflow_description" msgid="559796923090723804">"Zatvoriť rozbaľovaciu ponuku"</string>
    <string name="maximize_button_text" msgid="7543285286182446254">"Maximalizovať"</string>
    <string name="close_button_text" msgid="3937902162644062866">"Zavrieť"</string>
    <string name="notification_messaging_title_template" msgid="3452480118762691020">"<xliff:g id="CONVERSATION_TITLE">%1$s</xliff:g>: <xliff:g id="SENDER_NAME">%2$s</xliff:g>"</string>
    <plurals name="selected_count" formatted="false" msgid="7187339492915744615">
      <item quantity="few">Vybrané: <xliff:g id="COUNT_1">%1$d</xliff:g></item>
      <item quantity="many">Vybrané: <xliff:g id="COUNT_1">%1$d</xliff:g></item>
      <item quantity="other">Vybrané: <xliff:g id="COUNT_1">%1$d</xliff:g></item>
      <item quantity="one">Vybrané: <xliff:g id="COUNT_0">%1$d</xliff:g></item>
    </plurals>
    <string name="default_notification_channel_label" msgid="5929663562028088222">"Nekategorizované"</string>
    <string name="importance_from_user" msgid="7318955817386549931">"Nastavili ste dôležitosť týchto upozornení."</string>
    <string name="importance_from_person" msgid="9160133597262938296">"Táto správa je dôležitá vzhľadom na osoby, ktorých sa to týka."</string>
    <string name="user_creation_account_exists" msgid="1942606193570143289">"Povoliť aplikácii <xliff:g id="APP">%1$s</xliff:g> vytvoriť nového používateľa pomocou účtu <xliff:g id="ACCOUNT">%2$s</xliff:g>?"</string>
    <string name="user_creation_adding" msgid="4482658054622099197">"Povoliť aplikácii <xliff:g id="APP">%1$s</xliff:g> vytvoriť nového používateľa pomocou účtu <xliff:g id="ACCOUNT">%2$s</xliff:g> (používateľ s týmto účtom už existuje)?"</string>
    <string name="language_selection_title" msgid="2680677278159281088">"Pridať jazyk"</string>
    <string name="country_selection_title" msgid="2954859441620215513">"Preferovaný región"</string>
    <string name="search_language_hint" msgid="7042102592055108574">"Zadajte názov jazyka"</string>
    <string name="language_picker_section_suggested" msgid="8414489646861640885">"Navrhované"</string>
    <string name="language_picker_section_all" msgid="3097279199511617537">"Všetky jazyky"</string>
    <string name="region_picker_section_all" msgid="8966316787153001779">"Všetky regióny"</string>
    <string name="locale_search_menu" msgid="2560710726687249178">"Vyhľadávanie"</string>
    <string name="work_mode_off_title" msgid="2615362773958585967">"Aktivovať pracovný režim?"</string>
    <string name="work_mode_off_message" msgid="2961559609199223594">"Týmto aktivujete pracovný profil vrátane aplikácií, synchronizácie na pozadí a súvisiacich funkcií"</string>
    <string name="work_mode_turn_on" msgid="2062544985670564875">"Zapnúť"</string>
    <string name="new_sms_notification_title" msgid="8442817549127555977">"Máte nové správy."</string>
    <string name="new_sms_notification_content" msgid="7002938807812083463">"Otvorte aplikáciu pre SMS a zobrazte správu"</string>
    <string name="user_encrypted_title" msgid="9054897468831672082">"Niektoré funkcie môžu byť obmedzené"</string>
    <string name="user_encrypted_message" msgid="4923292604515744267">"Odomknite klepnutím"</string>
    <string name="user_encrypted_detail" msgid="5708447464349420392">"Údaje používateľa sú uzamknuté"</string>
    <string name="profile_encrypted_detail" msgid="3700965619978314974">"Pracovný profil je uzamknutý"</string>
    <string name="profile_encrypted_message" msgid="6964994232310195874">"Profil odomknete klepnutím"</string>
    <string name="usb_mtp_launch_notification_title" msgid="8359219638312208932">"Pripojené k zariadeniu <xliff:g id="PRODUCT_NAME">%1$s</xliff:g>"</string>
    <string name="usb_mtp_launch_notification_description" msgid="8541876176425411358">"Klepnutím zobrazíte súbory"</string>
    <string name="pin_target" msgid="3052256031352291362">"Pripnúť"</string>
    <string name="unpin_target" msgid="3556545602439143442">"Uvoľniť"</string>
    <string name="app_info" msgid="6856026610594615344">"Info o aplikácii"</string>
    <string name="negative_duration" msgid="5688706061127375131">"-<xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="demo_starting_message" msgid="5268556852031489931">"Spúšťa sa ukážka…"</string>
    <string name="demo_restarting_message" msgid="952118052531642451">"Resetuje sa zariadenie…"</string>
    <string name="suspended_widget_accessibility" msgid="6712143096475264190">"Deaktivovaná miniaplikácia <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="conference_call" msgid="3751093130790472426">"Konferenčný hovor"</string>
    <string name="tooltip_popup_title" msgid="5253721848739260181">"Popis"</string>
    <string name="app_category_game" msgid="5431836943981492993">"Hry"</string>
    <string name="app_category_audio" msgid="1659853108734301647">"Hudba a zvuk"</string>
    <string name="app_category_video" msgid="2728726078629384196">"Filmy a videá"</string>
    <string name="app_category_image" msgid="4867854544519846048">"Fotky a obrázky"</string>
    <string name="app_category_social" msgid="5842783057834965912">"Sociálne siete a komunikácia"</string>
    <string name="app_category_news" msgid="7496506240743986873">"Noviny a časopisy"</string>
    <string name="app_category_maps" msgid="5878491404538024367">"Mapy a navigácia"</string>
    <string name="app_category_productivity" msgid="3742083261781538852">"Produktivita"</string>
    <string name="device_storage_monitor_notification_channel" msgid="3295871267414816228">"Úložisko zariadenia"</string>
    <string name="adb_debugging_notification_channel_tv" msgid="5537766997350092316">"Ladenie cez USB"</string>
    <string name="time_picker_hour_label" msgid="2979075098868106450">"hodina"</string>
    <string name="time_picker_minute_label" msgid="5168864173796598399">"minúta"</string>
    <string name="time_picker_header_text" msgid="143536825321922567">"Nastaviť čas"</string>
    <string name="time_picker_input_error" msgid="7574999942502513765">"Zadajte platný čas"</string>
    <string name="time_picker_prompt_label" msgid="7588093983899966783">"Zadajte čas"</string>
    <string name="time_picker_text_input_mode_description" msgid="4148166758173708199">"Ak chcete zadať čas, prepnite na textový režim vstupu"</string>
    <string name="time_picker_radial_mode_description" msgid="4953403779779557198">"Ak chcete zadať čas, prepnite na režim hodín."</string>
    <string name="autofill_picker_accessibility_title" msgid="8469043291648711535">"Možnosti automatického dopĺňania"</string>
    <string name="autofill_save_accessibility_title" msgid="7244365268417107822">"Uložiť do Automatického dopĺňania"</string>
    <string name="autofill_error_cannot_autofill" msgid="7402758580060110371">"Obsah nie je možné automaticky vyplniť"</string>
    <string name="autofill_picker_no_suggestions" msgid="3908514303773350735">"Žiadne návrhy automatického dopĺňania"</string>
    <plurals name="autofill_picker_some_suggestions" formatted="false" msgid="5506565809835815274">
      <item quantity="few"><xliff:g id="COUNT">%1$s</xliff:g> návrhy automatického dopĺňania</item>
      <item quantity="many"><xliff:g id="COUNT">%1$s</xliff:g> návrhu automatického dopĺňania</item>
      <item quantity="other"><xliff:g id="COUNT">%1$s</xliff:g> návrhov automatického dopĺňania</item>
      <item quantity="one">Jeden návrh automatického dopĺňania</item>
    </plurals>
    <string name="autofill_save_title" msgid="3345527308992082601">"Uložiť do služby &lt;b&gt;<xliff:g id="LABEL">%1$s</xliff:g>&lt;/b&gt;?"</string>
    <string name="autofill_save_title_with_type" msgid="8637809388029313305">"Uložiť <xliff:g id="TYPE">%1$s</xliff:g> do služby &lt;b&gt;<xliff:g id="LABEL">%2$s</xliff:g>&lt;/b&gt;?"</string>
    <string name="autofill_save_title_with_2types" msgid="5214035651838265325">"Uložiť <xliff:g id="TYPE_0">%1$s</xliff:g> a <xliff:g id="TYPE_1">%2$s</xliff:g> do služby &lt;b&gt;<xliff:g id="LABEL">%3$s</xliff:g>&lt;/b&gt;?"</string>
    <string name="autofill_save_title_with_3types" msgid="6943161834231458441">"Uložiť <xliff:g id="TYPE_0">%1$s</xliff:g>, <xliff:g id="TYPE_1">%2$s</xliff:g> a <xliff:g id="TYPE_2">%3$s</xliff:g> do služby &lt;b&gt;<xliff:g id="LABEL">%4$s</xliff:g>&lt;/b&gt;?"</string>
    <string name="autofill_save_yes" msgid="6398026094049005921">"Uložiť"</string>
    <string name="autofill_save_no" msgid="2625132258725581787">"Nie, vďaka"</string>
    <string name="autofill_save_type_password" msgid="5288448918465971568">"heslo"</string>
    <string name="autofill_save_type_address" msgid="4936707762193009542">"adresa"</string>
    <string name="autofill_save_type_credit_card" msgid="7127694776265563071">"kreditná karta"</string>
    <string name="autofill_save_type_username" msgid="239040540379769562">"používateľské meno"</string>
    <string name="autofill_save_type_email_address" msgid="5752949432129262174">"e-mailová adresa"</string>
    <string name="etws_primary_default_message_earthquake" msgid="5541962250262769193">"Zachovajte pokoj a vyhľadajte úkryt v okolí."</string>
    <string name="etws_primary_default_message_tsunami" msgid="1887685943498368548">"Okamžite začnite evakuáciu z prímorských a nábrežných oblastí na bezpečnejšie miesto, napríklad do vyššie položených regiónov."</string>
    <string name="etws_primary_default_message_earthquake_and_tsunami" msgid="998797956848445862">"Zachovajte pokoj a vyhľadajte úkryt v okolí."</string>
    <string name="etws_primary_default_message_test" msgid="2709597093560037455">"Test tiesňových správ"</string>
    <string name="notification_reply_button_accessibility" msgid="3621714652387814344">"Odpovedať"</string>
    <string name="etws_primary_default_message_others" msgid="6293148756130398971"></string>
    <string name="mmcc_authentication_reject" msgid="7729819349669603406">"SIM karta je zakázaná"</string>
    <string name="mmcc_imsi_unknown_in_hlr" msgid="6321202257374418726">"SIM karta nie je k dispozícii"</string>
    <string name="mmcc_illegal_ms" msgid="2769452751852211112">"SIM karta je zakázaná"</string>
    <string name="mmcc_illegal_me" msgid="4438696681169345015">"Telefón je zakázaný"</string>
    <string name="popup_window_default_title" msgid="4874318849712115433">"Automaticky otvárané okno"</string>
</resources>
