<?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="kilobyteShort" msgid="7542884022844556968">"kB"</string>
    <string name="megabyteShort" msgid="6355851576770428922">"MB"</string>
    <string name="gigabyteShort" msgid="3259882455212193214">"GB"</string>
    <string name="terabyteShort" msgid="231613018159186962">"TB"</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">"Režim bez vyrušení"</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="5221736429761078014">"Žiadna mobilná dátová služba"</string>
    <string name="RestrictedOnEmergencyTitle" msgid="6855466023161191166">"Tiesňové volania nie sú k dispozícii"</string>
    <string name="RestrictedOnNormalTitle" msgid="3179574012752700984">"Žiadne hlasové hovory"</string>
    <string name="RestrictedOnAllVoiceTitle" msgid="8037246983606545202">"Žiadna hlasová služba ani tiesňové volania"</string>
    <string name="RestrictedStateContent" msgid="6538703255570997248">"Dočasne vypnuté operátorom"</string>
    <string name="RestrictedStateContentMsimTemplate" msgid="673416791370248176">"Dočasne vypnuté operátorom pre SIM kartu <xliff:g id="SIMNUMBER">%d</xliff:g>"</string>
    <string name="NetworkPreferenceSwitchTitle" msgid="6982395015324165258">"Nepodarilo sa pripojiť k mobilnej sieti"</string>
    <string name="NetworkPreferenceSwitchSummary" msgid="509327194863482733">"Skúste zmeniť predvolenú sieť. Zmeníte ju klepnutím."</string>
    <string name="EmergencyCallWarningTitle" msgid="813380189532491336">"Tiesňové volania nie sú k dispozícii"</string>
    <string name="EmergencyCallWarningSummary" msgid="1899692069750260619">"Nedajú sa uskutočniť tiesňové volania cez Wi-Fi"</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="notification_channel_sim" msgid="4052095493875188564">"Stav SIM karty"</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="3855061241207182194">"Volanie cez Wi-Fi sa nepodarilo nastaviť"</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="7372514042696663278">"Pri registrácii volania cez Wi‑Fi u operátora nastala chyba <xliff:g id="CODE">%1$s</xliff:g>"</item>
  </string-array>
    <!-- no translation found for wfcSpnFormat_spn (4998685024207291232) -->
    <skip />
    <string name="wfcSpnFormat_spn_wifi_calling" msgid="136001023263502280">"<xliff:g id="SPN">%s</xliff:g> volanie cez Wi-Fi"</string>
    <string name="wfcSpnFormat_wlan_call" msgid="2533371081782489793">"Volanie cez WLAN"</string>
    <string name="wfcSpnFormat_spn_wlan_call" msgid="2315240198303197168">"<xliff:g id="SPN">%s</xliff:g> volanie cez WLAN"</string>
    <string name="wfcSpnFormat_spn_wifi" msgid="6546481665561961938">"<xliff:g id="SPN">%s</xliff:g> Wi-Fi"</string>
    <string name="wfcSpnFormat_wifi_calling_bar_spn" msgid="1726178784338466265">"Volanie cez WiFi | <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_vowifi" msgid="4444638298656953681">"<xliff:g id="SPN">%s</xliff:g> VoWifi"</string>
    <string name="wfcSpnFormat_wifi_calling" msgid="4990486735013125329">"Volanie cez Wi‑Fi"</string>
    <string name="wfcSpnFormat_wifi" msgid="1892673884655959773">"Wi-Fi"</string>
    <string name="wfcSpnFormat_wifi_calling_wo_hyphen" msgid="1336669776254502831">"Volanie cez Wi‑Fi"</string>
    <string name="wfcSpnFormat_vowifi" msgid="1765176406171272629">"VoWifi"</string>
    <string name="wifi_calling_off_summary" msgid="8720659586041656098">"Vypnuté"</string>
    <string name="wfc_mode_wifi_preferred_summary" msgid="7335489823608689868">"Volanie cez Wi-Fi"</string>
    <string name="wfc_mode_cellular_preferred_summary" msgid="7081742743152286290">"Volanie cez mobilnú sieť"</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="7036196943673524858">"Nie je možné synchronizovať"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="4884451152168188763">"Pokúsili ste sa odstrániť príliš mnoho položiek typu <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_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="work_profile_deleted_reason_maximum_password_failure" msgid="8986903510053359694">"Príliš veľa pokusov o zadanie hesla"</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="9024647691106150160">"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="printing_disabled_by" msgid="8936832919072486965">"Tlač zakázala aplikácia <xliff:g id="OWNER_APP">%s</xliff:g>."</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">"Tieseň"</string>
    <string name="global_action_bug_report" msgid="7934010578922304799">"Hlásenie o chybách"</string>
    <string name="global_action_logout" msgid="935179188218826050">"Ukončiť reláciu"</string>
    <string name="global_action_screenshot" msgid="8329831278085426283">"Snímka"</string>
    <string name="bugreport_title" msgid="5981047024855257269">"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="1099326950891078929">"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_heavy_weight_app" msgid="6218742927792852607">"Aplikácia je spustená"</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="8836124313744349203">"Prepnúť na osobný profil"</string>
    <string name="managed_profile_label" msgid="8947929265267690522">"Prepnúť na pracovný profil"</string>
    <string name="permgrouplab_contacts" msgid="3657758145679177612">"Kontakty"</string>
    <string name="permgroupdesc_contacts" msgid="6951499528303668046">"prístup ku kontaktom"</string>
    <string name="permgrouprequest_contacts" msgid="6032805601881764300">"Povoliť aplikácii &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; 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="permgrouprequest_location" msgid="3788275734953323491">"Povoliť aplikácii &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; prístup k polohe tohto zariadenia?"</string>
    <string name="permgrouprequestdetail_location" msgid="1347189607421252902">"Aplikácia bude mať prístup k polohe iba vtedy, keď ju budete používať"</string>
    <string name="permgroupbackgroundrequest_location" msgid="5039063878675613235">"Chcete povoliť aplikácii <xliff:g id="APP_NAME">%1$s</xliff:g> prístup k polohe tohto zariadenia po celý čas?"</string>
    <string name="permgroupbackgroundrequestdetail_location" msgid="4597006851453417387">"Aplikácia má momentálne prístup k polohe iba vtedy, keď ju budete používať"</string>
    <string name="permgrouplab_calendar" msgid="5863508437783683902">"Kalendár"</string>
    <string name="permgroupdesc_calendar" msgid="3889615280211184106">"prístup ku kalendáru"</string>
    <string name="permgrouprequest_calendar" msgid="289900767793189421">"Povoliť aplikácii &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; 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="permgrouprequest_sms" msgid="7168124215838204719">"Povoliť aplikácii &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; odosielať a zobrazovať správy 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="permgrouprequest_storage" msgid="7885942926944299560">"Povoliť aplikácii &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; používať fotky, médiá a súbory v zariadení?"</string>
    <string name="permgrouplab_microphone" msgid="171539900250043464">"Mikrofón"</string>
    <string name="permgroupdesc_microphone" msgid="4988812113943554584">"nahrávanie zvuku"</string>
    <string name="permgrouprequest_microphone" msgid="9167492350681916038">"Povoliť aplikácii &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; zaznamenávať zvuk?"</string>
    <string name="permgrouplab_activityRecognition" msgid="1565108047054378642">"Fyzická aktivita"</string>
    <string name="permgroupdesc_activityRecognition" msgid="6949472038320473478">"prístup k vašej fyzickej aktivite"</string>
    <string name="permgrouprequest_activityRecognition" msgid="7626438016904799383">"Povoliť aplikácii &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; prístup k vašej fyzickej aktivite?"</string>
    <string name="permgrouplab_camera" msgid="4820372495894586615">"Fotoaparát"</string>
    <string name="permgroupdesc_camera" msgid="3250611594678347720">"fotenie a natáčanie videí"</string>
    <string name="permgrouprequest_camera" msgid="1299833592069671756">"Povoliť aplikácii &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; snímať fotky a zaznamenávať video?"</string>
    <string name="permgrouplab_calllog" msgid="8798646184930388160">"Denníky hovorov"</string>
    <string name="permgroupdesc_calllog" msgid="3006237336748283775">"čítanie a zapisovanie do denníka hovorov telefónu"</string>
    <string name="permgrouprequest_calllog" msgid="8487355309583773267">"Povoliť aplikácii &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; prístup k denníku hovorov telefónu?"</string>
    <string name="permgrouplab_phone" msgid="5229115638567440675">"Telefón"</string>
    <string name="permgroupdesc_phone" msgid="6234224354060641055">"telefonovanie a správu hovorov"</string>
    <string name="permgrouprequest_phone" msgid="9166979577750581037">"Povoliť aplikácii &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; uskutočňovať a spravovať telefonické hovory?"</string>
    <string name="permgrouplab_sensors" msgid="4838614103153567532">"Telové senzory"</string>
    <string name="permgroupdesc_sensors" msgid="7147968539346634043">"prístup k dátam senzorov vašich životných funkcií"</string>
    <string name="permgrouprequest_sensors" msgid="6349806962814556786">"Povoliť aplikácii &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; používať údaje senzorov o vašich životných funkciách?"</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ádať priblíženie 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čkom prstu"</string>
    <string name="capability_desc_canCaptureFingerprintGestures" msgid="4386487962402228670">"Dokáže zaznamenať gestá na senzore odtlačkov prstov zariadenia."</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_foregroundService" msgid="3310786367649133115">"spustiť službu v popredí"</string>
    <string name="permdesc_foregroundService" msgid="6471634326171344622">"Umožňuje aplikácii používať služby v popredí"</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="6265109654698562427">"prístup k presnej polohe iba v popredí"</string>
    <string name="permdesc_accessFineLocation" msgid="3520508381065331098">"Táto aplikácia dokáže získať vašu presnú polohu iba vtedy, keď je spustená v popredí. Na to, aby mohla používať služby určovania polohy, musia byť tieto služby zapnuté a k dispozícii v telefóne. Môže to zvýšiť spotebu batérie."</string>
    <string name="permlab_accessCoarseLocation" msgid="3707180371693213469">"prístup k približnej polohe (pomocou siete) iba v popredí"</string>
    <string name="permdesc_accessCoarseLocation" product="tablet" msgid="8594719010575779120">"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, keď je spustená v popredí. Na to, aby aplikácia mohla používať služby určovania polohy, musia byť tieto služby zapnuté a k dispozícii v tablete."</string>
    <string name="permdesc_accessCoarseLocation" product="tv" msgid="3027871910200890806">"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, keď je spustená v popredí. Na to, aby aplikácia mohla používať služby určovania polohy, musia byť tieto služby zapnuté a k dispozícii v televízore."</string>
    <string name="permdesc_accessCoarseLocation" product="default" msgid="854896049371048754">"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, ale iba keď je spustená v popredí. Na to, aby aplikácia mohla používať služby určovania polohy, musia byť tieto služby zapnuté a k dispozícii v telefóne."</string>
    <string name="permlab_accessBackgroundLocation" msgid="3965397804300661062">"prístup k polohe na pozadí"</string>
    <string name="permdesc_accessBackgroundLocation" msgid="1096394429579210251">"Ak okrem prístupu k približnej alebo presnej polohe udelíte aj toto povolenie, aplikácia bude môcť používať polohu, keď bude spustená na pozadí."</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_activityRecognition" msgid="3634590230567608356">"rozpoznávanie fyzickej aktivity"</string>
    <string name="permdesc_activityRecognition" msgid="3143453925156552894">"Táto aplikácia dokáže rozpoznať vašu fyzickú aktivitu."</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 tiesňovú linku."</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_callCompanionApp" msgid="3599252979411970473">"zobrazenie a kontrola hovorov prostredníctvom systému."</string>
    <string name="permdesc_callCompanionApp" msgid="4567344683275099090">"Umožňuje aplikácii zobrazovať a kontrolovať prebiehajúce hovory v zariadení. Táto možnosť zahŕňa údaje, akými sú napríklad čísla jednotlivých hovorov alebo stav hovorov."</string>
    <string name="permlab_acceptHandover" msgid="2661534649736022409">"pokračovať v hovore z inej aplikácie"</string>
    <string name="permdesc_acceptHandovers" msgid="4570660484220539698">"Umožňuje aplikácii pokračovať v hovore začatom v inej aplikácii."</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_requestPasswordComplexity" msgid="202650535669249674">"požadovať zložitosť zámky obrazovky"</string>
    <string name="permdesc_requestPasswordComplexity" msgid="4730994229754212347">"Umožňuje aplikácii zapamätať si úroveň zložitosti zámky obrazovky (vysoká, stredná, nízka alebo žiadna), ktorá udáva pravdepodobný rozsah dĺžky a typu zámky obrazovky. Aplikácia tiež navrhuje používateľom aktualizáciu zámky obrazovky na určitú úroveň, používatelia sa však môžu na základe vlastného uváženia rozhodnúť tento návrh ignorovať a prejsť inam. Upozorňujeme, že zámka obrazovky nie je uložená vo forme obyčajného textu, takže aplikácia nepozná presné heslo."</string>
    <string name="permlab_useBiometric" msgid="8837753668509919318">"používať biometrický hardvér"</string>
    <string name="permdesc_useBiometric" msgid="8389855232721612926">"Umožňuje aplikácii používať na overenie totožnosti biometrický hardvér"</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="permlab_audioWrite" msgid="2661772059799779292">"upravovať hudobnú zbierku"</string>
    <string name="permdesc_audioWrite" msgid="8888544708166230494">"Umožňuje aplikácii upravovať hudobnú zbierku."</string>
    <string name="permlab_videoWrite" msgid="128769316366746446">"upravovať zbierku videí"</string>
    <string name="permdesc_videoWrite" msgid="5448565757490640841">"Umožňuje aplikácii upravovať zbierku videí."</string>
    <string name="permlab_imagesWrite" msgid="3391306186247235510">"upravovať zbierku fotiek"</string>
    <string name="permdesc_imagesWrite" msgid="7073662756617474375">"Umožňuje aplikácii upravovať zbierku fotiek."</string>
    <string name="permlab_mediaLocation" msgid="8675148183726247864">"čítať polohy zo zbierky médií"</string>
    <string name="permdesc_mediaLocation" msgid="2237023389178865130">"Umožňuje aplikácii čítať polohy zo zbierky médií."</string>
    <string name="biometric_dialog_default_title" msgid="881952973720613213">"Overte, že ste to vy"</string>
    <string name="biometric_error_hw_unavailable" msgid="645781226537551036">"Biometrický hardvér nie je k dispozícii"</string>
    <string name="biometric_error_user_canceled" msgid="2260175018114348727">"Overenie bolo zrušené"</string>
    <string name="biometric_not_recognized" msgid="5770511773560736082">"Nerozpoznané"</string>
    <string name="biometric_error_canceled" msgid="349665227864885880">"Overenie bolo zrušené"</string>
    <string name="biometric_error_device_not_secured" msgid="6583143098363528349">"Nie je nastavený PIN, vzor ani heslo"</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_authenticated" msgid="5309333983002526448">"Odtlačok bol overený"</string>
    <string name="face_authenticated_no_confirmation_required" msgid="4018680978348659031">"Tvár bola overená"</string>
    <string name="face_authenticated_confirmation_required" msgid="8778347003507633610">"Tvár bola overená, stlačte tlačidlo potvrdenia"</string>
    <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_user_canceled" msgid="7999639584615291494">"Overenie odtlačku prsta zrušil používateľ."</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_error_no_fingerprints" msgid="7654382120628334248">"Neregistrovali ste žiadne odtlačky prstov."</string>
    <string name="fingerprint_error_hw_not_present" msgid="409523969613176352">"Toto zariadenie nemá senzor odtlačkov prstov."</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_manageFace" msgid="2137540986007309781">"správa hardvéru na overenie tváre"</string>
    <string name="permdesc_manageFace" msgid="8919637120670185330">"Umožňuje aplikácii vyvolať metódy, ktoré pridávajú a odstraňujú šablóny tvárí."</string>
    <string name="permlab_useFaceAuthentication" msgid="8996134460546804535">"používanie hardvéru na overenie tváre"</string>
    <string name="permdesc_useFaceAuthentication" msgid="5011118722951833089">"Umožňuje aplikácii používať na overenie totožnosti hardvér na overenie tváre"</string>
    <string name="face_recalibrate_notification_name" msgid="3976629945250435054">"Overenie tváre"</string>
    <string name="face_recalibrate_notification_title" msgid="4087620069451499365">"Znova zaregistrujte svoju tvár"</string>
    <string name="face_recalibrate_notification_content" msgid="5530308842361499835">"Znova zaregistrujte svoju tvár, aby sa zlepšilo rozpoznávanie"</string>
    <string name="face_acquired_insufficient" msgid="2767330364802375742">"Nepodarilo sa nasnímať presné údaje o tvári. Skúste to znova."</string>
    <string name="face_acquired_too_bright" msgid="5005650874582450967">"Príliš veľa svetla. Skúste jemnejšie osvetlenie."</string>
    <string name="face_acquired_too_dark" msgid="1966194696381394616">"Príliš veľká tma. Skúste lepšie osvetlenie."</string>
    <string name="face_acquired_too_close" msgid="1401011882624272753">"Oddiaľte telefón."</string>
    <string name="face_acquired_too_far" msgid="1210969240069012510">"Priblížte telefón."</string>
    <string name="face_acquired_too_high" msgid="3362395713403348013">"Posuňte telefón vyššie."</string>
    <string name="face_acquired_too_low" msgid="488983581737550912">"Posuňte telefón nižšie."</string>
    <string name="face_acquired_too_right" msgid="3667075962661863218">"Posuňte telefón doľava."</string>
    <string name="face_acquired_too_left" msgid="3148242963894703424">"Posuňte telefón doprava."</string>
    <string name="face_acquired_poor_gaze" msgid="8471716624377228327">"Pozrite sa na obrazovku s otvorenými očami."</string>
    <string name="face_acquired_not_detected" msgid="4885504661626728809">"Nie je vidieť vašu tvár. Pozrite sa na telefón."</string>
    <string name="face_acquired_too_much_motion" msgid="3149332171102108851">"Priveľa pohybu. Nehýbte telefónom."</string>
    <string name="face_acquired_recalibrate" msgid="8077949502893707539">"Znova zaregistrujte svoju tvár."</string>
    <string name="face_acquired_too_different" msgid="7663983770123789694">"Tvár už nie je možné rozpoznať. Skúste to znova."</string>
    <string name="face_acquired_too_similar" msgid="1508776858407646460">"Príliš rovnaké, zmeňte postoj."</string>
    <string name="face_acquired_pan_too_extreme" msgid="1852495480382773759">"Pozrite sa priamejšie na obrazovku."</string>
    <string name="face_acquired_tilt_too_extreme" msgid="1290820400317982049">"Pozrite sa priamejšie na obrazovku."</string>
    <string name="face_acquired_roll_too_extreme" msgid="1444829237745898619">"Zvisle vyrovnajte hlavu."</string>
    <string name="face_acquired_obscured" msgid="5747521031647744553">"Odstráňte prekážky medzi vašou hlavou a telefónom."</string>
    <string name="face_acquired_sensor_dirty" msgid="364493868630891300">"Vyčistite fotoaparát."</string>
  <string-array name="face_acquired_vendor">
  </string-array>
    <string name="face_error_hw_not_available" msgid="396883585636963908">"Tvár sa nedá overiť. Hardvér nie je k dispozícii."</string>
    <string name="face_error_timeout" msgid="2605673935810019129">"Vypršal časový limit tváre. Skúste to znova."</string>
    <string name="face_error_no_space" msgid="2712120617457553825">"Nové údaje o tvári sa nedajú uložiť. Najprv odstráňte jeden zo starých záznamov."</string>
    <string name="face_error_canceled" msgid="2768146728600802422">"Operácia týkajúca sa tváre bola zrušená"</string>
    <string name="face_error_user_canceled" msgid="9003022830076496163">"Overenie tváre bolo zrušené používateľom"</string>
    <string name="face_error_lockout" msgid="3407426963155388504">"Príliš veľa pokusov. Skúste to znova neskôr."</string>
    <string name="face_error_lockout_permanent" msgid="3485837851962070925">"Príliš veľa pokusov. Overenie tváre bolo deaktivované."</string>
    <string name="face_error_unable_to_process" msgid="4940944939691171539">"Nedá sa overiť tvár. Skúste to znova."</string>
    <string name="face_error_not_enrolled" msgid="2600952202843125796">"Overenie tváre ste nenastavili"</string>
    <string name="face_error_hw_not_present" msgid="1317845121210260372">"Toto zariadenie nepodporuje overenie tváre"</string>
    <string name="face_name_template" msgid="7004562145809595384">"Tvár <xliff:g id="FACEID">%d</xliff:g>"</string>
  <string-array name="face_error_vendor">
  </string-array>
    <string name="face_icon_content_description" msgid="4024817159806482191">"Ikona tváre"</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" msgid="1438933556581438863">"čítanie obsahu zdieľaného úložiska"</string>
    <string name="permdesc_sdcardRead" msgid="1804941689051236391">"Umožňuje aplikácii čítať obsah zdieľaného úložiska."</string>
    <string name="permlab_sdcardWrite" msgid="9220937740184960897">"upravovanie alebo odstraňovanie obsahu zdieľaného úložiska"</string>
    <string name="permdesc_sdcardWrite" msgid="2834431057338203959">"Umožňuje aplikácii zapisovať obsah zdieľaného úložiska."</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 režimu bez vyrušení"</string>
    <string name="permdesc_access_notification_policy" msgid="3296832375218749580">"Umožňuje aplikácii čítať a zapisovať konfiguráciu režimu bez vyrušení."</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">"Deaktivovať niektoré funkcie zámky obrazovky"</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="2044755691354158439">"Zabrániť 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">"Tiesňová linka"</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_sim_pin_unlock" msgid="9149698847116962307">"Odomknutie pomocou kódu PIN SIM karty."</string>
    <string name="keyguard_accessibility_sim_puk_unlock" msgid="9106899279724723341">"Odomknutie pomocou kódu PUK SIM karty."</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_window_title" msgid="4107745526909284887">"Automatické dopĺňanie pomocou služby <xliff:g id="SERVICENAME">%1$s</xliff:g>"</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="copied" msgid="8564151838171791598">"Skopírované"</string>
    <string name="more_item_label" msgid="4650918923083320495">"Viac"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Menu+"</string>
    <string name="menu_meta_shortcut_label" msgid="4647153495550313570">"Meta+"</string>
    <string name="menu_ctrl_shortcut_label" msgid="3917070091228880941">"Ctrl+"</string>
    <string name="menu_alt_shortcut_label" msgid="6249849492641218944">"Alt+"</string>
    <string name="menu_shift_shortcut_label" msgid="6773890288720306380">"Shift+"</string>
    <string name="menu_sym_shortcut_label" msgid="4019695553731017933">"Sym+"</string>
    <string name="menu_function_shortcut_label" msgid="1984053777418162618">"Function+"</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="failed_to_copy_to_clipboard" msgid="1833662432489814471">"Nepodarilo sa skopírovať do schránky"</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">"Poslať e-mail"</string>
    <string name="email_desc" msgid="3638665569546416795">"Napísať na vybratú e-mailovú adresu"</string>
    <string name="dial" msgid="1253998302767701559">"Volať"</string>
    <string name="dial_desc" msgid="6573723404985517250">"Zavolať na vybraté telefónne číslo"</string>
    <string name="map" msgid="5441053548030107189">"Otvoriť mapu"</string>
    <string name="map_desc" msgid="1836995341943772348">"Nájsť vybranú adresu"</string>
    <string name="browse" msgid="1245903488306147205">"Otvoriť"</string>
    <string name="browse_desc" msgid="8220976549618935044">"Otvoriť vybratú webovú adresu"</string>
    <string name="sms" msgid="4560537514610063430">"Poslať správu"</string>
    <string name="sms_desc" msgid="7526588350969638809">"Napísať SMS na vybraté telefónne číslo"</string>
    <string name="add_contact" msgid="7867066569670597203">"Pridať"</string>
    <string name="add_contact_desc" msgid="4830217847004590345">"Pridať medzi kontakty"</string>
    <string name="view_calendar" msgid="979609872939597838">"Zobraziť"</string>
    <string name="view_calendar_desc" msgid="5828320291870344584">"Zobraziť vybratý čas v kalendári"</string>
    <string name="add_calendar_event" msgid="1953664627192056206">"Naplánovať"</string>
    <string name="add_calendar_event_desc" msgid="4326891793260687388">"Naplánovať udalosť na vybratý čas"</string>
    <string name="view_flight" msgid="7691640491425680214">"Sledovať"</string>
    <string name="view_flight_desc" msgid="3876322502674253506">"Sledovať vybratý let"</string>
    <string name="translate" msgid="9218619809342576858">"Preložiť"</string>
    <string name="translate_desc" msgid="4502367770068777202">"Preložiť vybraný text"</string>
    <string name="define" msgid="7394820043869954211">"Definovať"</string>
    <string name="define_desc" msgid="7910883642444919726">"Definovať vybraný text"</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="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="whichGiveAccessToApplication" msgid="8279395245414707442">"Udeľte prístup na otváranie odkazov <xliff:g id="HOST">%1$s</xliff:g> pomocou aplikácie"</string>
    <string name="whichGiveAccessToApplicationNamed" msgid="7992388824107710849">"Udeľte prístup na otváranie odkazov <xliff:g id="HOST">%1$s</xliff:g> pomocou aplikácie <xliff:g id="APPLICATION">%2$s</xliff:g>"</string>
    <string name="whichGiveAccessToApplicationLabel" msgid="6142688895536868827">"Udeliť prístup"</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="5803792421724377602">"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 vstupnej aplikácie"</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="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="unsupported_compile_sdk_message" msgid="4253168368781441759">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> bola zostavená pre nekompatibilnú verziu systému Android OS a môže sa správať neočakávane. Môže byť k dispozícii aktualizovaná verzia tejto aplikácie."</string>
    <string name="unsupported_compile_sdk_show" msgid="2681877855260970231">"Vždy zobrazovať"</string>
    <string name="unsupported_compile_sdk_check_update" msgid="3312723623323216101">"Skontrolovať dostupnosť aktualizácie"</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" product="default" msgid="7513829952443484438">"Telefón sa aktualizuje…"</string>
    <string name="android_upgrading_title" product="tablet" msgid="4503169817302593560">"Tablet sa aktualizuje…"</string>
    <string name="android_upgrading_title" product="device" msgid="7009520271220804517">"Zariadenie sa aktualizuje…"</string>
    <string name="android_start_title" product="default" msgid="4536778526365907780">"Telefón sa spúšťa…"</string>
    <string name="android_start_title" product="automotive" msgid="8418054686415318207">"Systém Android sa spúšťa…"</string>
    <string name="android_start_title" product="tablet" msgid="4929837533850340472">"Tablet sa spúšťa…"</string>
    <string name="android_start_title" product="device" msgid="7467484093260449437">"Zariadenie sa spúšťa…"</string>
    <string name="android_upgrading_fstrim" msgid="8036718871534640010">"Optimalizuje sa úložisko"</string>
    <string name="android_upgrading_notification_title" product="default" msgid="1511552415039349062">"Dokončuje sa aktualizácia systému…"</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="2304833848484424985">"Klepnutím prejdete späť do hry"</string>
    <string name="heavy_weight_switcher_title" msgid="387882830435195342">"Vyberte hru"</string>
    <string name="heavy_weight_switcher_text" msgid="4176781660362912010">"Na zaistenie lepšej výkonnosti môže byť naraz otvorená iba jedna z týchto hier."</string>
    <string name="old_app_action" msgid="3044685170829526403">"Prejsť späť do aplikácie <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_action" msgid="6694851182870774403">"Otvoriť <xliff:g id="NEW_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="5894852887817332322">"<xliff:g id="OLD_APP">%1$s</xliff:g> sa zavrie 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_ready_notification" msgid="1162196579925048701">"Zálohy údajov <xliff:g id="PROC">%1$s</xliff:g> sú pripravené"</string>
    <string name="dump_heap_notification_detail" msgid="3993078784053054141">"Boli zhromaždené zálohy dát. 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="8546022920319781701">"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é údaje, ku ktorým má táto aplikácia prístup."</string>
    <string name="dump_heap_system_text" msgid="3236094872980706024">"Proces <xliff:g id="PROC">%1$s</xliff:g> prekročil limit <xliff:g id="SIZE">%2$s</xliff:g> pre pamäť. Máte k dispozícii zálohy údajov, ktoré môžete zdieľať. Postupujte opatrne: tieto zálohy údajov môžu obsahovať všetky citlivé osobné údaje, ku ktorým má tento proces prístup (napríklad napísaný text)."</string>
    <string name="dump_heap_ready_text" msgid="1778041771455343067">"Máte k dispozícii zálohy údajov procesu <xliff:g id="PROC">%1$s</xliff:g>, ktoré môžete zdieľať. Postupujte opatrne: tieto zálohy údajov môžu obsahovať všetky citlivé osobné údaje, ku ktorým má tento proces prístup (napríklad napísaný text)."</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_carrier_network_title" msgid="4527932626916527897">"Pripojenie k sieti Wi‑Fi operátora"</string>
    <string name="wifi_available_title_connecting" msgid="1139126673968899002">"Pripája sa k 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="4368435796357931006">"Všetky siete"</string>
    <string name="wifi_suggestion_title" msgid="9099832833531486167">"Chcete sa pripojiť k sieťam Wi‑Fi?"</string>
    <string name="wifi_suggestion_content" msgid="5883181205841582873">"Navrhuje <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="wifi_suggestion_action_allow_app" msgid="3689946344485394085">"Áno"</string>
    <string name="wifi_suggestion_action_disallow_app" msgid="7977918905605931385">"Nie"</string>
    <string name="wifi_wakeup_onboarding_title" msgid="228772560195634292">"Wi‑Fi sa zapne automaticky"</string>
    <string name="wifi_wakeup_onboarding_subtext" msgid="3989697580301186973">"Keď budete v blízkosti kvalitnej uloženej siete"</string>
    <string name="wifi_wakeup_onboarding_action_disable" msgid="838648204200836028">"Znova nezapínať"</string>
    <string name="wifi_wakeup_enabled_title" msgid="6534603733173085309">"Pripojenie Wi‑Fi sa zaplo automaticky"</string>
    <string name="wifi_wakeup_enabled_content" msgid="189330154407990583">"Ste v blízkosti uloženej siete: <xliff:g id="NETWORK_SSID">%1$s</xliff:g>"</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="5198100389964214865">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> nemá prístup k internetu"</string>
    <string name="wifi_no_internet_detailed" msgid="8083079241212301741">"Klepnutím získate možnosti"</string>
    <string name="captive_portal_logged_in_detailed" msgid="8489345381637456021">"Pripojené"</string>
    <string name="network_partial_connectivity" msgid="7774883385494762741">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> má obmedzené pripojenie"</string>
    <string name="network_partial_connectivity_detailed" msgid="1959697814165325217">"Ak sa chcete aj napriek tomu pripojiť, klepnite"</string>
    <string name="wifi_softap_config_change" msgid="8475911871165857607">"Zmeny nastavení hotspotu"</string>
    <string name="wifi_softap_config_change_summary" msgid="7601233252456548891">"Pásmo vášho hotspotu sa zmenilo."</string>
    <string name="wifi_softap_config_change_detailed" msgid="8022936822860678033">"Toto zariadenie nepodporuje vašu predvoľbu používať iba 5 GHz. Namiesto toho bude pásmo 5 GHz používať vtedy, keď bude k dispozícii."</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="775163331794506615">"Keď <xliff:g id="PREVIOUS_NETWORK">%2$s</xliff:g> nemá prístup k internetu, zariadenie používa <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="4917472096696322767">" 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">"Zamietnuť"</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="install_carrier_app_notification_title" msgid="9056007111024059888">"Aktivovať mobilnú službu"</string>
    <string name="install_carrier_app_notification_text" msgid="3346681446158696001">"Ak chcete aktivovať novú SIM kartu, stiahnite si aplikáciu operátora"</string>
    <string name="install_carrier_app_notification_text_app_name" msgid="1196505084835248137">"Ak chcete aktivovať novú SIM kartu, stiahnite si aplikáciu <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="install_carrier_app_notification_button" msgid="3094206295081900849">"Stiahnuť aplikáciu"</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="1595122345358177163">"Toto zariadenie sa nabíja cez USB"</string>
    <string name="usb_supplying_notification_title" msgid="4631045789893086181">"Pripojené zariadenie sa nabíja cez USB"</string>
    <string name="usb_mtp_notification_title" msgid="4238227258391151029">"Bol aktivovaný prenos súborov cez USB"</string>
    <string name="usb_ptp_notification_title" msgid="5425857879922006878">"Bol zapnutý režim PTP cez USB"</string>
    <string name="usb_tether_notification_title" msgid="3716143122035802501">"Bol zapnutý tethering cez USB"</string>
    <string name="usb_midi_notification_title" msgid="5356040379749154805">"Bol zapnutý režim MIDI cez USB"</string>
    <string name="usb_accessory_notification_title" msgid="1785694450621427730">"Bolo pripojené príslušenstvo USB"</string>
    <string name="usb_notification_message" msgid="3370903770828407960">"Klepnutím zobrazíte ďalšie možnosti."</string>
    <string name="usb_power_notification_message" msgid="4647527153291917218">"Pripojené zariadenie sa nabíja. Ďalšie možností získate klepnutím."</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="7463062450474107752">"Klepnutím vypnite 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="test_harness_mode_notification_title" msgid="2216359742631914387">"Režim správcu testov je aktivovaný"</string>
    <string name="test_harness_mode_notification_message" msgid="1343197173054407119">"Ak chcete zakázať režim správcu testov, obnovte výrobné nastavenia."</string>
    <string name="usb_contaminant_detected_title" msgid="7136400633704058349">"Tekutina alebo nečistoty v porte USB"</string>
    <string name="usb_contaminant_detected_message" msgid="832337061059487250">"Port USB je automaticky deaktivovaný. Ďalšie informácie zobrazíte klepnutím."</string>
    <string name="usb_contaminant_not_detected_title" msgid="4202417484434906086">"Port USB môžete bezpečne používať"</string>
    <string name="usb_contaminant_not_detected_message" msgid="2415791798244545292">"Telefón už nerozpoznáva tekutinu ani nečistoty."</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="4653387336791222978">"Zvoliť metódu vstupu"</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="2902891971380544651">"Vypnúť"</string>
    <string name="ext_media_checking_notification_title" msgid="4411133692439308924">"Kontroluje sa <xliff:g id="NAME">%s</xliff:g>…"</string>
    <string name="ext_media_checking_notification_message" msgid="410185170877285434">"Kontrola aktuálneho obsahu"</string>
    <string name="ext_media_new_notification_title" msgid="1621805083736634077">"Nové médium <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_new_notification_message" msgid="3673685270558405087">"Klepnutím médium nastavte"</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="4179418065210797130">"Problém s médiom <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unmountable_notification_message" msgid="4193858924381066522">"Problém odstránite 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="8556885808951260574">"Pred odobratím médium najskôr odpojte, aby ste zabránili strate obsahu"</string>
    <string name="ext_media_nomedia_notification_title" msgid="6593814191061956856">"Médium <xliff:g id="NAME">%s</xliff:g> bolo odobraté"</string>
    <string name="ext_media_nomedia_notification_message" msgid="2110883356419799994">"Niektoré funkcie nemusia byť k dispozícii. Vložte nové úložisko."</string>
    <string name="ext_media_unmounting_notification_title" msgid="5046532339291216076">"Odpája sa médium <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unmounting_notification_message" msgid="1003926904442321115">"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_seamless_action" msgid="6575980560886881233">"Prepnúť výstup"</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="4012389235250987930">"Zariadenie vložte znova"</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="7863652232242276066">"Prenos obsahu je hotový"</string>
    <string name="ext_media_move_success_message" msgid="8939137931961728009">"Obsah bol presunutý do úložiska <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_failure_title" msgid="1604422634177382092">"Obsah sa nepodarilo presunúť"</string>
    <string name="ext_media_move_failure_message" msgid="7388950499623016135">"Skúste obsah presunúť znova"</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="735805531187559719">"Odpojené od vždy zapnutej siete VPN"</string>
    <string name="vpn_lockdown_error" msgid="3133844445659711681">"Nepodarilo sa pripojiť k sieti VPN, ktorá je vždy zapnutá"</string>
    <string name="vpn_lockdown_config" msgid="8151951501116759194">"Zmeniť sieť alebo nastavenia VPN"</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">"Resetovať"</string>
    <string name="submit" msgid="1602335572089911941">"Odoslať"</string>
    <string name="car_mode_disable_notification_title" msgid="5704265646471239078">"Aplikácia na šoférovanie je spustená"</string>
    <string name="car_mode_disable_notification_message" msgid="7647248420931129377">"Klepnutím ukončíte aplikáciu na šoférovanie"</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="disable_tether_notification_title" msgid="7526977944111313195">"Tethering je deaktivovaný"</string>
    <string name="disable_tether_notification_message" msgid="2913366428516852495">"O podrobnosti požiadajte svojho správcu"</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" msgid="2569962663843586562">"Vymazáva sa zdieľané úložisko…"</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="6499834033204801605">"Dátové upozornenie"</string>
    <string name="data_usage_warning_body" msgid="7340198905103751676">"Využili ste <xliff:g id="APP">%s</xliff:g> dát"</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="2908179506560812973">"Dáta boli pozastavené do konca cyklu"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="3171402244827034372">"Prekročený limit mobilných dát"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="3547771791046344188">"Prekročený limit dát cez Wi-Fi"</string>
    <string name="data_usage_limit_snoozed_body" msgid="1671222777207603301">"Prekročili ste stanovený limit o <xliff:g id="SIZE">%s</xliff:g>"</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="data_usage_rapid_title" msgid="1809795402975261331">"Vysoké využitie mobilných dát"</string>
    <string name="data_usage_rapid_body" msgid="6897825788682442715">"Vaše aplikácie využili viac dát než zvyčajne"</string>
    <string name="data_usage_rapid_app_body" msgid="5396680996784142544">"Aplikácia <xliff:g id="APP">%s</xliff:g> využila viac dát než zvyčajne"</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_app_settings" msgid="8965806928986509855">"Nastavenia"</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_dock_speakers" msgid="6240602982276591864">"Reproduktory doku"</string>
    <string name="default_audio_route_name_hdmi" msgid="1486254205617081251">"HDMI"</string>
    <string name="default_audio_route_name_headphones" msgid="8119971843803439110">"Slúchadlá"</string>
    <string name="default_audio_route_name_usb" msgid="1234984851352637769">"USB"</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="activity_starter_block_bg_activity_starts_permissive" msgid="6995473033438879646">"Toto spustenie aktivity na pozadí v režime <xliff:g id="PACKAGENAME">%1$s</xliff:g> bude blokované v budúcich zostavách Q. Pozrite si informácie na g.co/dev/bgblock."</string>
    <string name="activity_starter_block_bg_activity_starts_enforcing" msgid="3317816771072146229">"Spustenie aktivity na pozadí v režime <xliff:g id="PACKAGENAME">%1$s</xliff:g> je blokované. Pozrite si informácie na g.co/dev/bgblock."</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>
    <plurals name="kg_too_many_failed_attempts_countdown" formatted="false" msgid="8790651267324125694">
      <item quantity="few">Skúste to znova o <xliff:g id="NUMBER">%d</xliff:g> sekundy.</item>
      <item quantity="many">Skúste to znova o <xliff:g id="NUMBER">%d</xliff:g> sekundy.</item>
      <item quantity="other">Skúste to znova o <xliff:g id="NUMBER">%d</xliff:g> sekúnd.</item>
      <item quantity="one">Skúste to znova o 1 sekundu.</item>
    </plurals>
    <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="color_inversion_feature_name" msgid="4231186527799958644">"Inverzia farieb"</string>
    <string name="color_correction_feature_name" msgid="6779391426096954933">"Úprava farieb"</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_shortcut_spoken_feedback" msgid="8376923232350078434">"Ak chcete používať službu <xliff:g id="SERVICE_NAME">%1$s</xliff:g>, pridržte tri sekundy oba klávesy hlasitosti"</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 potiahnutím 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_unlock_pin" msgid="2552556656504331634">"Pred odopnutí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="confirm_battery_saver" msgid="639106420541753635">"OK"</string>
    <string name="battery_saver_description_with_learn_more" msgid="2108984221113106294">"Šetrič batérie vypne alebo obmedzí aktivitu na pozadí, niektoré vizuálne efekty a ďalšie energeticky náročné funkcie, aby predĺžil výdrž batérie. "<annotation id="url">"Ďalšie informácie"</annotation></string>
    <string name="battery_saver_description" msgid="6413346684861241431">"Šetrič batérie vypne alebo obmedzí aktivitu na pozadí, niektoré vizuálne efekty a ďalšie energeticky náročné funkcie, aby predĺžil výdrž batérie."</string>
    <string name="data_saver_description" msgid="6015391409098303235">"S cieľom znížiť spotrebu dát bráni šetrič dát niektorým aplikáciám odosielať alebo prijímať dáta na pozadí. Aplikácia, ktorú práve používate, môže využívať dáta, ale možno to bude 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="736789408293052283">
      <item quantity="few">Na %1$d hodiny (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="many">Na %1$d hodiny (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Na %1$d hodín (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Na 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="6571961796799076730">
      <item quantity="few">Na %d hodiny</item>
      <item quantity="many">Na %d hodiny</item>
      <item quantity="other">Na %d hodín</item>
      <item quantity="one">Na 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="931849471004038757">"Dokiaľ túto funkciu nevypnete"</string>
    <string name="zen_mode_forever_dnd" msgid="3792132696572189081">"Dokiaľ nevypnete režim bez vyrušení"</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">"Režim bez vyrušení"</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="zen_mode_default_every_night_name" msgid="3012363838882944175">"Spánok"</string>
    <string name="muted_by" msgid="5942954724562097128">"<xliff:g id="THIRD_PARTY">%1$s</xliff:g> vypína niektoré zvuky"</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="5214333646366591205">"Žiadosť USSD bola zmenená na bežný hovor"</string>
    <string name="stk_cc_ussd_to_ss" msgid="4884994189414782605">"Žiadosť USSD bola zmenená na žiadosť SS"</string>
    <string name="stk_cc_ussd_to_ussd" msgid="5728637484565449312">"Zmenené na novú žiadosť USSD"</string>
    <string name="stk_cc_ussd_to_dial_video" msgid="4134455726513175559">"Žiadosť USSD bola zmenená na videohovor"</string>
    <string name="stk_cc_ss_to_dial" msgid="1360775164651754978">"Žiadosť SS bola zmenená na bežný hovor"</string>
    <string name="stk_cc_ss_to_dial_video" msgid="6577956662913194947">"Žiadosť SS bola zmenená na videohovor"</string>
    <string name="stk_cc_ss_to_ussd" msgid="5614626512855868785">"Žiadosť SS bola zmenená na žiadosť USSD"</string>
    <string name="stk_cc_ss_to_ss" msgid="7716729801537709054">"Zmenené na novú žiadosť SS"</string>
    <string name="notification_work_profile_content_description" msgid="4600554564103770764">"Pracovný profil"</string>
    <string name="notification_alerted_content_description" msgid="1296617716556420585">"Upozornené"</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="app_suspended_title" msgid="2075071241147969611">"Aplikácia nie je k dispozícii"</string>
    <string name="app_suspended_default_message" msgid="123166680425711887">"Aplikácia <xliff:g id="APP_NAME_0">%1$s</xliff:g> nie je momentálne k dispozícii. Spravuje to aplikácia <xliff:g id="APP_NAME_1">%2$s</xliff:g>."</string>
    <string name="app_suspended_more_details" msgid="1131804827776778187">"Ďalšie informácie"</string>
    <string name="work_mode_off_title" msgid="1118691887588435530">"Zapnúť pracovný profil?"</string>
    <string name="work_mode_off_message" msgid="5130856710614337649">"Pracovné aplikácie, upozornenia, dáta a ďalšie funkcie pracovného profilu sa zapnú"</string>
    <string name="work_mode_turn_on" msgid="2062544985670564875">"Zapnúť"</string>
    <string name="deprecated_target_sdk_message" msgid="1449696506742572767">"Táto aplikácia bola zostavená pre staršiu verziu Androidu a nemusí správne fungovať. Skúste skontrolovať dostupnosť aktualizácií alebo kontaktovať vývojára."</string>
    <string name="deprecated_target_sdk_app_store" msgid="5032340500368495077">"Skontrolovať dostupnosť aktualizácie"</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="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="327541108460384555">"Uložiť do služby "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_type" msgid="2339135393607143594">"Chcete položku <xliff:g id="TYPE">%1$s</xliff:g> uložiť do služby "<b>"<xliff:g id="LABEL">%2$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_2types" msgid="87616102361154432">"Chcete položky <xliff:g id="TYPE_0">%1$s</xliff:g> a <xliff:g id="TYPE_1">%2$s</xliff:g> uložiť do služby "<b>"<xliff:g id="LABEL">%3$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_3types" msgid="4108978552969604555">"Chcete položky <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> uložiť do služby "<b>"<xliff:g id="LABEL">%4$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title" msgid="5305781141104585279">"Aktualizovať v službe "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_type" msgid="4624181147422762233">"Chcete údaje <xliff:g id="TYPE">%1$s</xliff:g> aktualizovať v službe "<b>"<xliff:g id="LABEL">%2$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_2types" msgid="2300113827053626484">"Chcete položky <xliff:g id="TYPE_0">%1$s</xliff:g> a <xliff:g id="TYPE_1">%2$s</xliff:g> aktualizovať v službe "<b>"<xliff:g id="LABEL">%3$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_3types" msgid="9089824354296211922">"Chcete tieto položky aktualizovať v službe "<b>"<xliff:g id="LABEL">%4$s</xliff:g>"</b>": <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>?"</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_update_yes" msgid="310358413273276958">"Aktualizovať"</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="5767701075994754356">"SIM karta nie je povolená pre hlas"</string>
    <string name="mmcc_imsi_unknown_in_hlr" msgid="5316658473301462825">"SIM karta nie je k dispozícii pre hlas"</string>
    <string name="mmcc_illegal_ms" msgid="807334478177362062">"SIM karta nie je povolená pre hlas"</string>
    <string name="mmcc_illegal_me" msgid="1950705155760872972">"Telefón nie je povolený pre hlas"</string>
    <string name="mmcc_authentication_reject_msim_template" msgid="1217031195834766479">"SIM karta <xliff:g id="SIMNUMBER">%d</xliff:g> nie je povolená"</string>
    <string name="mmcc_imsi_unknown_in_hlr_msim_template" msgid="5636464607596778986">"SIM karta <xliff:g id="SIMNUMBER">%d</xliff:g> nie je k dispozícii"</string>
    <string name="mmcc_illegal_ms_msim_template" msgid="5994323296399913454">"SIM karta <xliff:g id="SIMNUMBER">%d</xliff:g> nie je povolená"</string>
    <string name="mmcc_illegal_me_msim_template" msgid="5550259730350571826">"SIM karta <xliff:g id="SIMNUMBER">%d</xliff:g> nie je povolená"</string>
    <string name="popup_window_default_title" msgid="4874318849712115433">"Automaticky otvárané okno"</string>
    <string name="slice_more_content" msgid="8504342889413274608">"+ <xliff:g id="NUMBER">%1$d</xliff:g>"</string>
    <string name="shortcut_restored_on_lower_version" msgid="4860853725206702336">"Aplikácia prešla na staršiu verziu alebo nie je kompatibilná s touto skratkou"</string>
    <string name="shortcut_restore_not_supported" msgid="5028808567940014190">"Odkaz sa nepodarilo obnoviť, pretože aplikácia nepodporuje zálohovanie a obnovu"</string>
    <string name="shortcut_restore_signature_mismatch" msgid="2406209324521327518">"Odkaz sa nepodarilo obnoviť pre nesúlad podpisov aplikácie"</string>
    <string name="shortcut_restore_unknown_issue" msgid="8703738064603262597">"Odkaz sa nepodarilo obnoviť"</string>
    <string name="shortcut_disabled_reason_unknown" msgid="5276016910284687075">"Skratka je zakázaná"</string>
    <string name="harmful_app_warning_uninstall" msgid="4837672735619532931">"ODINŠTALOVAŤ"</string>
    <string name="harmful_app_warning_open_anyway" msgid="596432803680914321">"OTVORIŤ AJ TAK"</string>
    <string name="harmful_app_warning_title" msgid="8982527462829423432">"Bola zistená škodlivá aplikácia"</string>
    <string name="slices_permission_request" msgid="8484943441501672932">"<xliff:g id="APP_0">%1$s</xliff:g> chce zobrazovať rezy z aplikácie <xliff:g id="APP_2">%2$s</xliff:g>"</string>
    <string name="screenshot_edit" msgid="7867478911006447565">"Upraviť"</string>
    <string name="volume_dialog_ringer_guidance_vibrate" msgid="8902050240801159042">"Hovory a upozornenia budú vibrovať"</string>
    <string name="volume_dialog_ringer_guidance_silent" msgid="2128975224280276122">"Hovory a upozornenia budú stlmené"</string>
    <string name="notification_channel_system_changes" msgid="5072715579030948646">"Zmeny systému"</string>
    <string name="notification_channel_do_not_disturb" msgid="6766940333105743037">"Režim bez vyrušení"</string>
    <string name="zen_upgrade_notification_visd_title" msgid="3288313883409759733">"Novinka: režim bez vyrušení skrýva upozornenia"</string>
    <string name="zen_upgrade_notification_visd_content" msgid="5533674060311631165">"Klepnutím získate ďalšie informácie a budete môcť vykonať zmeny."</string>
    <string name="zen_upgrade_notification_title" msgid="3799603322910377294">"Režim bez vyrušení sa zmenil"</string>
    <string name="zen_upgrade_notification_content" msgid="1794994264692424562">"Klepnutím skontrolujete, čo je blokované."</string>
    <string name="notification_app_name_system" msgid="4205032194610042794">"Systém"</string>
    <string name="notification_app_name_settings" msgid="7751445616365753381">"Nastavenia"</string>
    <string name="notification_appops_camera_active" msgid="5050283058419699771">"Fotoaparát"</string>
    <string name="notification_appops_microphone_active" msgid="4335305527588191730">"Mikrofón"</string>
    <string name="notification_appops_overlay_active" msgid="633813008357934729">"sa zobrazuje cez ďalšie aplikácie na obrazovke"</string>
    <string name="dynamic_mode_notification_channel_name" msgid="2348803891571320452">"Upozornenie s informáciami o rutinnom režime"</string>
    <string name="dynamic_mode_notification_title" msgid="508815255807182035">"Batéria sa môže vybiť pred obvyklým nabitím"</string>
    <string name="dynamic_mode_notification_summary" msgid="2541166298550402690">"Bol aktivovaný šetrič batérie na predĺženie výdrže batérie"</string>
    <string name="battery_saver_notification_channel_name" msgid="2083316159716201806">"Šetrič batérie"</string>
    <string name="battery_saver_sticky_disabled_notification_title" msgid="6376147579378764641">"Šetrič batérie sa znova aktivuje až pri nízkej úrovni nabitia batérie"</string>
    <string name="battery_saver_sticky_disabled_notification_summary" msgid="8090192609249817945">"Batéria bola nabitá na dostatočnú úroveň. Šetrič batérie sa znova aktivuje až pri nízkej úrovni nabitia batérie."</string>
    <string name="battery_saver_charged_notification_title" product="default" msgid="2960978289873161288">"Úroveň nabitia telefónu: <xliff:g id="CHARGE_LEVEL">%1$s</xliff:g>"</string>
    <string name="battery_saver_charged_notification_title" product="tablet" msgid="7555713825806482451">"Úroveň nabitia tabletu: <xliff:g id="CHARGE_LEVEL">%1$s</xliff:g>"</string>
    <string name="battery_saver_charged_notification_title" product="device" msgid="5954873381559605660">"Úroveň nabitia zariadenia: <xliff:g id="CHARGE_LEVEL">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_notification_summary" msgid="1374222493681267143">"Šetrič batérie je vypnutý. Funkcie už nie sú obmedzené."</string>
    <string name="battery_saver_off_alternative_notification_summary" msgid="4340727818546508436">"Šetrič batérie bol vypnutý. Funkcie už nie sú obmedzené."</string>
    <string name="mime_type_folder" msgid="7111951698626315204">"Priečinok"</string>
    <string name="mime_type_apk" msgid="5518003630972506900">"Aplikácia pre Android"</string>
    <string name="mime_type_generic" msgid="6833871596845900027">"Súbor"</string>
    <string name="mime_type_generic_ext" msgid="8450275970061657174">"Súbor <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_audio" msgid="6289777657172050926">"Zvuk"</string>
    <string name="mime_type_audio_ext" msgid="3270880987725816210">"Zvuk <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_video" msgid="4093025777317307426">"Video"</string>
    <string name="mime_type_video_ext" msgid="5643771615714173159">"Video <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_image" msgid="3144284451605236371">"Obrázok"</string>
    <string name="mime_type_image_ext" msgid="1514613218742736590">"Obrázok <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_compressed" msgid="1645486037074943257">"Archív"</string>
    <string name="mime_type_compressed_ext" msgid="4232293058067801528">"Archív <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_document" msgid="1596838147256375966">"Dokument"</string>
    <string name="mime_type_document_ext" msgid="6327266601345501281">"Dokument <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_spreadsheet" msgid="2639138255207123557">"Tabuľka"</string>
    <string name="mime_type_spreadsheet_ext" msgid="5508653032786106725">"Tabuľka <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_presentation" msgid="6145604688774787357">"Prezentácia"</string>
    <string name="mime_type_presentation_ext" msgid="2982650207774823437">"Prezentácia <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="car_loading_profile" msgid="3545132581795684027">"Načítava sa"</string>
    <plurals name="file_count" formatted="false" msgid="1628600959752419449">
      <item quantity="few"><xliff:g id="FILE_NAME_2">%s</xliff:g> + <xliff:g id="COUNT_3">%d</xliff:g> súbory</item>
      <item quantity="many"><xliff:g id="FILE_NAME_2">%s</xliff:g> + <xliff:g id="COUNT_3">%d</xliff:g> files</item>
      <item quantity="other"><xliff:g id="FILE_NAME_2">%s</xliff:g> + <xliff:g id="COUNT_3">%d</xliff:g> súborov</item>
      <item quantity="one"><xliff:g id="FILE_NAME_0">%s</xliff:g> + <xliff:g id="COUNT_1">%d</xliff:g> súbor</item>
    </plurals>
    <string name="chooser_no_direct_share_targets" msgid="997970693708458895">"Priame zdieľanie nie je k dispozícii"</string>
</resources>
