<?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="5973789783504771878">"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="9164292791500531949">"<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="ellipsis" msgid="7899829516048813237">"…"</string>
    <string name="ellipsis_two_dots" msgid="1228078994866030736">"‥"</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(žiadne telefónne číslo)"</string>
    <string name="unknownName" msgid="2277556546742746522">"(Neznáme)"</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 režim čísla pevného vytáčania."</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 zakázaná."</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">"Karta SIM je uzamknutá pomocou kódu PUK. Odomknite ju zadaním kódu PUK."</string>
    <string name="needPuk2" msgid="4526033371987193070">"Ak chcete odblokovať kartu SIM, zadajte kód PUK2."</string>
    <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="CfMmi" msgid="5123218989141573515">"Presmerovanie hovorov"</string>
    <string name="CwMmi" msgid="9129678056795016867">"Čakajúci hovor"</string>
    <string name="BaMmi" msgid="455193067926770581">"Blokovanie hovorov"</string>
    <string name="PwdMmi" msgid="7043715687905254199">"Zmena hesla"</string>
    <string name="PinMmi" msgid="3113117780361190304">"Zmena kódu PIN"</string>
    <string name="CnipMmi" msgid="3110534680557857162">"Volané číslo uvedené"</string>
    <string name="CnirMmi" msgid="3062102121430548731">"Volanie čísla obmedzené"</string>
    <string name="ThreeWCMmi" msgid="9051047170321190368">"Konferencia troch účastníkov"</string>
    <string name="RuacMmi" msgid="7827887459138308886">"Odmietnutie nevyžiadaných obťažujúcich hovorov"</string>
    <string name="CndMmi" msgid="3116446237081575808">"Doručenie volaného čísla"</string>
    <string name="DndMmi" msgid="1265478932418334331">"Nerušiť"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="429415409145781923">"V predvolenom nastavení je identifikácia volajúceho obmedzená. Ďalší hovor: Obmedzené"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="3092918006077864624">"V predvolenom nastavení je identifikácia volajúceho obmedzená. Ďalší hovor: Bez obmedzenia"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="6179425182856418465">"V predvolenom nastavení nie je identifikácia volajúceho obmedzená. Ďalší hovor: Obmedzené"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2567998633124408552">"V predvolenom nastavení nie je identifikácia volajúceho obmedzená. Ďalší hovor: Bez obmedzenia"</string>
    <string name="serviceNotProvisioned" msgid="8614830180508686666">"Služba nie je poskytovaná."</string>
    <string name="CLIRPermanent" msgid="3377371145926835671">"Nemôžete meniť nastavenia identifikácie volajúceho."</string>
    <string name="RestrictedChangedTitle" msgid="5592189398956187498">"Obmedzený prístup bol zmenený"</string>
    <string name="RestrictedOnData" msgid="8653794784690065540">"Údajová služba je zablokovaná."</string>
    <string name="RestrictedOnEmergency" msgid="6581163779072833665">"Tiesňová služba je zablokovaná."</string>
    <string name="RestrictedOnNormal" msgid="4953867011389750673">"Hlasová služba je zablokovaná."</string>
    <string name="RestrictedOnAllVoice" msgid="3396963652108151260">"Všetky hlasové služby sú zablokované."</string>
    <string name="RestrictedOnSms" msgid="8314352327461638897">"Služba SMS je zablokovaná."</string>
    <string name="RestrictedOnVoiceData" msgid="996636487106171320">"Hlasové a dátové služby sú zablokované."</string>
    <string name="RestrictedOnVoiceSms" msgid="1888588152792023873">"Hlasové služby a služby SMS sú zablokované."</string>
    <string name="RestrictedOnAll" msgid="5643028264466092821">"Všetky hlasové, údajové služby a služby SMS sú zablokované."</string>
    <string name="serviceClassVoice" msgid="1258393812335258019">"Voice"</string>
    <string name="serviceClassData" msgid="872456782077937893">"Údaje"</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="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">"Adresu URL 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 adresa URL je neplatná."</string>
    <string name="httpErrorFile" msgid="2170788515052558676">"Prístup k súboru sa nepodarilo získať."</string>
    <string name="httpErrorFileNotFound" msgid="6203856612042655084">"Požadovaný súbor sa nepodarilo nájsť."</string>
    <string name="httpErrorTooManyRequests" msgid="1235396927087188253">"Je spracovávaných príliš veľa žiadostí. Opakujte akciu neskôr."</string>
    <string name="notification_title" msgid="8967710025036163822">"Chyba prihlásenia do účtu <xliff:g id="ACCOUNT">%1$s</xliff:g>"</string>
    <string name="contentServiceSync" msgid="8353523060269335667">"Synchronizovať"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="397743349191901458">"Synchronizovať"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="8100981435080696431">"Príliš veľa odstránených položiek služby <xliff:g id="CONTENT_TYPE">%s</xliff:g>."</string>
    <string name="low_memory" product="tablet" msgid="6494019234102154896">"Ukladací priestor tabletu je plný. Odstráňte niektoré súbory a uvoľnite miesto."</string>
    <string name="low_memory" product="default" msgid="3475999286680000541">"Pamäť telefónu je plná. Odstráňte niektoré súbory a uvoľnite miesto."</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="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">"Uzamknutie 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="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="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="default" msgid="2406416831541615258">"Možnosti telefónu"</string>
    <string name="global_action_lock" msgid="2844945191792119712">"Uzamknutie obrazovky"</string>
    <string name="global_action_power_off" msgid="4471879440839879722">"Vypnúť"</string>
    <string name="global_action_bug_report" msgid="7934010578922304799">"Správa o chybe"</string>
    <string name="bugreport_title" msgid="2667494803742548533">"Zaznamenať správu o chybe"</string>
    <string name="bugreport_message" msgid="398447048750350456">"Zhromažďuje informácie o aktuálnom stave zariadenia a tieto informácie je následne možné odoslať prostredníctvom e-mailovej správy. Od spustenia vytvárania správy o chybe až do chvíle, kedy je tento nástroj pripravený odoslať prvú správu, môže uplynúť nejaký čas. Prosíme vás preto o trpezlivosť."</string>
    <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="status_bar_notification_info_overflow" msgid="5301981741705354993">"999+"</string>
    <string name="safeMode" msgid="2788228061547930246">"Núdzový režim"</string>
    <string name="android_system_label" msgid="6577375335728551336">"Systém Android"</string>
    <string name="permgrouplab_costMoney" msgid="5429808217861460401">"Spoplatnené služby"</string>
    <string name="permgroupdesc_costMoney" msgid="3293301903409869495">"Vykonávanie činností, ktoré vás môžu stáť peniaze."</string>
    <string name="permgrouplab_messages" msgid="7521249148445456662">"Vaše správy"</string>
    <string name="permgroupdesc_messages" msgid="7821999071003699236">"Čítanie a písanie správ SMS, e-mailov a ďalších správ."</string>
    <string name="permgrouplab_personalInfo" msgid="3519163141070533474">"Vaše osobné informácie"</string>
    <string name="permgroupdesc_personalInfo" msgid="8426453129788861338">"Priamy prístup k informáciám o vás uložených na vašej karte kontaktu."</string>
    <string name="permgrouplab_socialInfo" msgid="5799096623412043791">"Vaše sociálne informácie"</string>
    <string name="permgroupdesc_socialInfo" msgid="7129842457611643493">"Priamy prístup k informáciám o vašich kontaktoch a sociálnych prepojeniach."</string>
    <string name="permgrouplab_location" msgid="635149742436692049">"Vaša poloha"</string>
    <string name="permgroupdesc_location" msgid="5704679763124170100">"Sledovanie vašej fyzickej polohy."</string>
    <string name="permgrouplab_network" msgid="5808983377727109831">"Sieťová komunikácia"</string>
    <string name="permgroupdesc_network" msgid="4478299413241861987">"Prístup k rôznym funkciám siete."</string>
    <string name="permgrouplab_bluetoothNetwork" msgid="1585403544162128109">"Bluetooth"</string>
    <string name="permgroupdesc_bluetoothNetwork" msgid="5625288577164282391">"Prístup k zariadeniam a sieťam prostredníctvom rozhrania Bluetooth."</string>
    <string name="permgrouplab_audioSettings" msgid="8329261670151871235">"Nastavenia zvuku"</string>
    <string name="permgroupdesc_audioSettings" msgid="2641515403347568130">"Zmena nastavení zvuku."</string>
    <string name="permgrouplab_affectsBattery" msgid="6209246653424798033">"Má vplyv na batériu"</string>
    <string name="permgroupdesc_affectsBattery" msgid="6441275320638916947">"Používanie funkcií, ktoré môžu rýchlo vyčerpať batériu."</string>
    <string name="permgrouplab_calendar" msgid="5863508437783683902">"Kalendár"</string>
    <string name="permgroupdesc_calendar" msgid="5777534316982184416">"Priamy prístup ku kalendáru a udalostiam."</string>
    <string name="permgrouplab_dictionary" msgid="4148597128843641379">"Čítanie požívateľského slovníka"</string>
    <string name="permgroupdesc_dictionary" msgid="7921166355964764490">"Čítanie slov v používateľskom slovníku."</string>
    <string name="permgrouplab_writeDictionary" msgid="8090237702432576788">"Zápis do používateľského slovníka"</string>
    <string name="permgroupdesc_writeDictionary" msgid="2711561994497361646">"Pridávanie slov do používateľského slovníka."</string>
    <string name="permgrouplab_bookmarks" msgid="1949519673103968229">"Záložky a história"</string>
    <string name="permgroupdesc_bookmarks" msgid="4169771606257963028">"Priamy prístup k záložkám a histórii prehliadača."</string>
    <string name="permgrouplab_deviceAlarms" msgid="6117704629728824101">"Budík"</string>
    <string name="permgroupdesc_deviceAlarms" msgid="4769356362251641175">"Nastavenie budíka."</string>
    <string name="permgrouplab_voicemail" msgid="4162237145027592133">"Hlasová schránka"</string>
    <string name="permgroupdesc_voicemail" msgid="2498403969862951393">"Priamy prístup do hlasovej schránky."</string>
    <string name="permgrouplab_microphone" msgid="171539900250043464">"Mikrofón"</string>
    <string name="permgroupdesc_microphone" msgid="7106618286905738408">"Priamy prístup k mikrofónu na záznam zvuku."</string>
    <string name="permgrouplab_camera" msgid="4820372495894586615">"Fotoaparát"</string>
    <string name="permgroupdesc_camera" msgid="2933667372289567714">"Priamy prístup k fotoaparátu na nasnímanie fotografií alebo natočenie videí."</string>
    <string name="permgrouplab_screenlock" msgid="8275500173330718168">"Uzamknúť obrazovku"</string>
    <string name="permgroupdesc_screenlock" msgid="7067497128925499401">"Možnosť ovplyvniť správanie zámky obrazovky na vašom zariadení."</string>
    <string name="permgrouplab_appInfo" msgid="8028789762634147725">"Informácie o vašich aplikáciách"</string>
    <string name="permgroupdesc_appInfo" msgid="3950378538049625907">"Schopnosť ovplyvniť správanie ďalších aplikácií na vašom zariadení."</string>
    <string name="permgrouplab_wallpaper" msgid="3850280158041175998">"Tapeta"</string>
    <string name="permgroupdesc_wallpaper" msgid="5630417854750540154">"Zmena nastavení tapety zariadenia."</string>
    <string name="permgrouplab_systemClock" msgid="406535759236612992">"Hodiny"</string>
    <string name="permgroupdesc_systemClock" msgid="3944359833624094992">"Zmena času a časového pásma zariadenia."</string>
    <string name="permgrouplab_statusBar" msgid="2095862568113945398">"Stavový riadok"</string>
    <string name="permgroupdesc_statusBar" msgid="6242593432226807171">"Zmena nastavení stavového riadka zariadenia."</string>
    <string name="permgrouplab_syncSettings" msgid="3341990986147826541">"Nastavenia synchronizácie"</string>
    <string name="permgroupdesc_syncSettings" msgid="7603195265129031797">"Prístup do nastavení synchronizácie."</string>
    <string name="permgrouplab_accounts" msgid="3359646291125325519">"Vaše účty"</string>
    <string name="permgroupdesc_accounts" msgid="4948732641827091312">"Prístup k dostupným účtom."</string>
    <string name="permgrouplab_hardwareControls" msgid="7998214968791599326">"Ovládanie hardvéru"</string>
    <string name="permgroupdesc_hardwareControls" msgid="4357057861225462702">"Priamy prístup k hardvéru telefónu."</string>
    <string name="permgrouplab_phoneCalls" msgid="9067173988325865923">"Telefónne hovory"</string>
    <string name="permgroupdesc_phoneCalls" msgid="7489701620446183770">"Sledovanie, záznam a spracovanie telefónnych hovorov."</string>
    <string name="permgrouplab_systemTools" msgid="4652191644082714048">"Systémové nástroje"</string>
    <string name="permgroupdesc_systemTools" msgid="8162102602190734305">"Nízkoúrovňový prístup a ovládanie systému."</string>
    <string name="permgrouplab_developmentTools" msgid="3446164584710596513">"Nástroje pre vývoj"</string>
    <string name="permgroupdesc_developmentTools" msgid="7058828032358142018">"Funkcie len pre vývojárov aplikácií."</string>
    <string name="permgrouplab_display" msgid="4279909676036402636">"Používateľské rozhranie iných aplikácií"</string>
    <string name="permgroupdesc_display" msgid="6051002031933013714">"Vplyv na používateľské rozhranie ďalších aplikácií."</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Ukladací priestor"</string>
    <string name="permgroupdesc_storage" product="nosdcard" msgid="7442318502446874999">"Prístup do ukl. priestoru USB."</string>
    <string name="permgroupdesc_storage" product="default" msgid="9203302214915355774">"Prístup na kartu SD."</string>
    <string name="permgrouplab_accessibilityFeatures" msgid="7919025602283593907">"Funkcie zjednodušenia ovládania"</string>
    <string name="permgroupdesc_accessibilityFeatures" msgid="4205196881678144335">"Funkcie, ktoré môže vyžadovať nápomocná technológia."</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="3901717936930170320">"Načítať obsah okna"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="3772225008605310672">"Preskúmať obsah okna s ktorým interagujete."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="3108723364676667320">"Zapnúť funkciu Preskúmanie dotykom"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="5800552516779249356">"Po dotyku na položku sa vysloví jej názov a obrazovku je možné preskúmať pomocou gest."</string>
    <string name="capability_title_canRequestEnhancedWebAccessibility" msgid="1739881766522594073">"Zapnúť vylepšenú dostupnosť na webe"</string>
    <string name="capability_desc_canRequestEnhancedWebAccessibility" msgid="7881063961507511765">"Môže nainštalovať skripty na sprístupnenie obsahu aplikácie."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2103440391902412174">"Sledovať vami zadávaný text"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="7463135292204152818">"Obsahuje osobné údaje ako sú čísla kreditných kariet a heslá."</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="7247281911387931485">"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_processOutgoingCalls" msgid="3906007831192990946">"presmerovať odchádzajúce hovory"</string>
    <string name="permdesc_processOutgoingCalls" msgid="5331318931937402040">"Umožňuje aplikácii spracovávať odchádzajúce hovory a meniť vytáčané číslo. Toto povolenie umožňuje aplikácii sledovať a presmerovať odchádzajúce hovory alebo im zabrániť."</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_receiveEmergencyBroadcast" msgid="1803477660846288089">"príjem núdzového vysielania"</string>
    <string name="permdesc_receiveEmergencyBroadcast" msgid="848524070262431974">"Umožňuje aplikácii prijímať a spracovávať správy núdzového vysielania. Toto povolenie je k dispozícii len pre systémové aplikácie."</string>
    <string name="permlab_readCellBroadcasts" msgid="1598328843619646166">"čítať správy Cell Broadcast"</string>
    <string name="permdesc_readCellBroadcasts" msgid="6361972776080458979">"Umožňuje aplikácii čítať správy Cell Broadcast prijaté vaším zariadením. Upozornenia Cell Broadcast sú doručované na určitých miestach a upozorňujú na núdzové situácie. Škodlivé aplikácie môžu pri prijatí núdzovej správy Cell Broadcast narušiť výkonnosť alebo prevádzku vášho zariadenia."</string>
    <string name="permlab_sendSms" msgid="5600830612147671529">"odosielať správy 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_sendRespondViaMessageRequest" msgid="8713889105305943200">"odosielanie udalostí typu „odpovedzte správou“"</string>
    <string name="permdesc_sendRespondViaMessageRequest" msgid="7107648548468778734">"Umožňuje aplikácii odosielať žiadosti ostatným aplikáciám na posielanie správ s cieľom spracovania udalostí typu „odpovedzte správou“ pre prichádzajúce hovory."</string>
    <string name="permlab_readSms" msgid="8745086572213270480">"čítať textové správy (SMS alebo MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="2467981548684735522">"Umožňuje aplikácii čítať správy SMS uložené v tablete alebo na karte SIM. Toto povolenie umožňuje aplikácii čítať správy SMS bez ohľadu na ich obsah alebo dôvernosť."</string>
    <string name="permdesc_readSms" product="default" msgid="3695967533457240550">"Umožňuje aplikácii čítať správy SMS uložené v telefóne alebo na karte SIM. Toto povolenie umožňuje aplikácii čítať správy SMS bez ohľadu na ich obsah alebo dôvernosť."</string>
    <string name="permlab_writeSms" msgid="3216950472636214774">"upraviť textové správy (SMS alebo MMS)"</string>
    <string name="permdesc_writeSms" product="tablet" msgid="5160413947794501538">"Umožňuje aplikácii písať správy SMS uložené v tablete alebo na karte SIM. Škodlivé aplikácie môžu vaše správy odstrániť."</string>
    <string name="permdesc_writeSms" product="default" msgid="7268668709052328567">"Umožňuje aplikácii písať do správ SMS uložených v telefóne alebo na karte SIM. Škodlivé aplikácie môžu vaše správy odstrániť."</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_interactAcrossUsers" msgid="7114255281944211682">"interakcie naprieč používateľmi"</string>
    <string name="permdesc_interactAcrossUsers" msgid="364670963623385786">"Umožňuje aplikácii vykonávať akcie naprieč rôznymi používateľmi zariadenia. Škodlivé aplikácie môžu toto povolenie zneužiť na obídenie ochrany medzi používateľmi."</string>
    <string name="permlab_interactAcrossUsersFull" msgid="2567734285545074105">"plná licencia na interakcie naprieč používateľmi"</string>
    <string name="permdesc_interactAcrossUsersFull" msgid="376841368395502366">"Umožňuje všetky možné interakcie naprieč používateľmi."</string>
    <string name="permlab_manageUsers" msgid="1676150911672282428">"správa používateľov"</string>
    <string name="permdesc_manageUsers" msgid="8409306667645355638">"Umožňuje aplikáciám spravovať používateľov v zariadení, vrátane vyhľadávania dopytov, vytvorenia a odstránenia."</string>
    <string name="permlab_getDetailedTasks" msgid="6229468674753529501">"načítať podrobnosti o spustených aplikáciách"</string>
    <string name="permdesc_getDetailedTasks" msgid="153824741440717599">"Umožňuje aplikácii načítať podrobné informácie o aktuálnych a nedávno spustených úlohách. Škodlivé aplikácie môžu odhaliť súkromné informácie o iných aplikáciách."</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_removeTasks" msgid="6821513401870377403">"zastaviť spustené aplikácie"</string>
    <string name="permdesc_removeTasks" msgid="1394714352062635493">"Umožňuje aplikácii odstrániť úlohy a ukončiť ich aplikácie. Škodlivé aplikácie môžu narušiť správanie iných aplikácií."</string>
    <string name="permlab_startAnyActivity" msgid="2918768238045206456">"spustiť ľubovoľnú aktivitu"</string>
    <string name="permdesc_startAnyActivity" msgid="997823695343584001">"Umožňuje aplikácii spustiť ľubovoľnú aktivitu bez ohľadu na ochranu povolení alebo exportovaný stav."</string>
    <string name="permlab_setScreenCompatibility" msgid="6975387118861842061">"nastaviť kompatibilitu obrazovky"</string>
    <string name="permdesc_setScreenCompatibility" msgid="692043618693917374">"Umožňuje aplikácii ovládať režim kompatibility obrazovky v ostatných aplikáciách. Škodlivé aplikácie môžu narušiť správanie ostatných aplikácií."</string>
    <string name="permlab_setDebugApp" msgid="3022107198686584052">"povoliť ladenie aplikácií"</string>
    <string name="permdesc_setDebugApp" msgid="4474512416299013256">"Umožňuje aplikácii zapnúť ladenie inej aplikácie. Škodlivé aplikácie môžu pomocou tohto nastavenia ukončiť iné aplikácie."</string>
    <string name="permlab_changeConfiguration" msgid="4162092185124234480">"zmeniť systémové nastavenia obrazovky"</string>
    <string name="permdesc_changeConfiguration" msgid="4372223873154296076">"Umožňuje aplikácii zmeniť aktuálnu konfiguráciu, napr. miestne nastavenie alebo celkovú veľkosť písma."</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_forceStopPackages" msgid="2329627428832067700">"vynútiť zastavenie ďalších aplikácií"</string>
    <string name="permdesc_forceStopPackages" msgid="5253157296183940812">"Umožňuje aplikácii vynútiť zastavenie iných aplikácií."</string>
    <string name="permlab_forceBack" msgid="652935204072584616">"vynútiť zavretie aplikácie"</string>
    <string name="permdesc_forceBack" msgid="3892295830419513623">"Umožňuje aplikácii vynútiť ukončenie a návrat akejkoľvek aktivity, ktorá je v popredí. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_dump" msgid="1681799862438954752">"načítanie interného stavu systému"</string>
    <string name="permdesc_dump" msgid="1778299088692290329">"Umožňuje aplikácii načítať interný stav systému. Škodlivé aplikácie môžu načítať široký rozsah súkromných a zabezpečených informácií, ktoré by obvykle nemali nikdy potrebovať."</string>
    <string name="permlab_retrieve_window_content" msgid="8022588608994589938">"načítanie obsahu obrazovky"</string>
    <string name="permdesc_retrieve_window_content" msgid="3193269069469700265">"Umožňuje aplikácii načítať obsah aktívneho okna. Škodlivé aplikácie môžu získať celý obsah okna a preskúmať celý jeho text okrem hesiel."</string>
    <string name="permlab_temporary_enable_accessibility" msgid="2312612135127310254">"dočasné povolenie zjednodušenia ovládania"</string>
    <string name="permdesc_temporary_enable_accessibility" msgid="8079456293182975464">"Umožňuje aplikácii dočasne povoliť zjednodušenie ovládania v zariadení. Škodlivé aplikáciu môžu zjednodušenie ovládania povoliť bez súhlasu používateľa."</string>
    <string name="permlab_retrieve_window_info" msgid="8532295199112519378">"načítanie informácií o oknách"</string>
    <string name="permdesc_retrieve_window_info" msgid="4998836370424186849">"Umožňuje aplikácii načítať informácie o oknách zo správcu okien. Škodlivé aplikácie môžu načítať informácie, ktoré sú určené pre interné využitie systému."</string>
    <string name="permlab_filter_events" msgid="8675535648807427389">"filtrovanie udalostí"</string>
    <string name="permdesc_filter_events" msgid="8006236315888347680">"Umožňuje aplikácii zaregistrovať vstupný filter, ktorý filtruje stream všetkých prenosov používateľa pred ich odvysielaním. Škodlivá aplikácia môže bez zásahu používateľa ovládať používateľské rozhranie systému."</string>
    <string name="permlab_magnify_display" msgid="5973626738170618775">"priblížiť zobrazenie"</string>
    <string name="permdesc_magnify_display" msgid="7121235684515003792">"Umožňuje aplikácii priblížiť obsah displeja. Škodlivé aplikácie môžu zmeniť zobrazenie obsahu tak, že sa zariadenie stane nepoužiteľným."</string>
    <string name="permlab_shutdown" msgid="7185747824038909016">"Čiastočné vypnutie"</string>
    <string name="permdesc_shutdown" msgid="7046500838746291775">"Uvedie správcu činností do vypnutého stavu. Úplné vypnutie však nenastane."</string>
    <string name="permlab_stopAppSwitches" msgid="4138608610717425573">"zabrániť prepínaniu aplikácií"</string>
    <string name="permdesc_stopAppSwitches" msgid="8262195802582255021">"Zabráni používateľovi prepnúť na inú aplikáciu."</string>
    <string name="permlab_getTopActivityInfo" msgid="2537922311411546016">"získať informácie o aktuálnej aplikácii"</string>
    <string name="permdesc_getTopActivityInfo" msgid="2512448855496067131">"Umožňuje držiteľovi povolenia načítať súkromné ​​informácie o aktuálnej aplikácii v popredí obrazovky."</string>
    <string name="permlab_runSetActivityWatcher" msgid="892239094867182656">"sledovať a ovládať všetky spustenia aplikácií"</string>
    <string name="permdesc_runSetActivityWatcher" msgid="6003603162578577406">"Umožňuje aplikácii sledovať a ovládať spúšťanie aktivít systémom. Škodlivé aplikácie môžu systém úplne ovládnuť. Toto povolenie je potrebné len na účely vývoja, nikdy nie na bežné používanie."</string>
    <string name="permlab_broadcastPackageRemoved" msgid="2576333434893532475">"odoslanie vysielania o odstránení balíčka"</string>
    <string name="permdesc_broadcastPackageRemoved" msgid="6621901216207931089">"Umožňuje aplikácii vysielať oznámenie, že balík aplikácie bol odstránený. Škodlivé aplikácie môžu pomocou tohto nastavenia ukončiť akúkoľvek ďalšiu spustenú aplikáciu."</string>
    <string name="permlab_broadcastSmsReceived" msgid="5689095009030336593">"odoslanie vysielania o prijatej správe SMS"</string>
    <string name="permdesc_broadcastSmsReceived" msgid="4152037720034365492">"Umožňuje aplikácii vysielať oznámenie, že správa SMS bola doručená. Škodlivé aplikácie môžu toto nastavenie použiť na falšovanie prichádzajúcich správ SMS."</string>
    <string name="permlab_broadcastWapPush" msgid="3145347413028582371">"odoslanie vysielania typu WAP-PUSH-received"</string>
    <string name="permdesc_broadcastWapPush" msgid="4783402525039442729">"Umožňuje aplikácii vysielať oznámenie, že správa WAP PUSH bola doručená. Škodlivé aplikácie môžu použiť toto nastavenie na vytvorenie potvrdenia o doručení správy MMS alebo na utajené nahradenie obsahu akejkoľvek stránky škodlivými variantmi."</string>
    <string name="permlab_setProcessLimit" msgid="2451873664363662666">"obmedzenie počtu spustených procesov"</string>
    <string name="permdesc_setProcessLimit" msgid="7318061314040879542">"Umožňuje aplikácii kontrolovať maximálny počet spustených procesov. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_setAlwaysFinish" msgid="550958507798796965">"vynútiť zavretie aplikácií na pozadí"</string>
    <string name="permdesc_setAlwaysFinish" msgid="7471310652868841499">"Umožňuje aplikácii ovládať, či sa aktivity po presune na pozadie vždy ukončia. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_batteryStats" msgid="2789610673514103364">"čítať štatistické údaje o batérii"</string>
    <string name="permdesc_batteryStats" msgid="5897346582882915114">"Umožňuje aplikácii čítať aktuálne údaje nízkej úrovne o používaní batérie. Pomocou tejto funkcie môže aplikácia zistiť podrobnosti o tom, ktoré aplikácie používate."</string>
    <string name="permlab_updateBatteryStats" msgid="3719689764536379557">"zmena štatistických údajov o batérii"</string>
    <string name="permdesc_updateBatteryStats" msgid="6862817857178025002">"Umožňuje aplikácii zmeniť zhromaždené štatistické údaje o batérii. Bežné aplikácie toto nastavenie nepoužívajú."</string>
    <string name="permlab_getAppOpsStats" msgid="1508779687436585744">"získať štatistické údaje o fungovaní aplikácií"</string>
    <string name="permdesc_getAppOpsStats" msgid="6243887041577912877">"Umožňuje aplikácii získať zhromaždené štatistické údaje o fungovaní aplikácií. Bežné aplikácie toto nastavenie nepoužívajú."</string>
    <string name="permlab_updateAppOpsStats" msgid="8829097373851521505">"upraviť štatistické údaje o fungovaní aplikácií"</string>
    <string name="permdesc_updateAppOpsStats" msgid="50784596594403483">"Umožňuje aplikácii zmeniť zhromaždené štatistické údaje o fungovaní aplikácií. Bežné aplikácie toto nastavenie nepoužívajú."</string>
    <string name="permlab_backup" msgid="470013022865453920">"Ovládať zálohovanie a obnovu systému"</string>
    <string name="permdesc_backup" msgid="6912230525140589891">"Umožňuje aplikácii ovládať mechanizmus na zálohovanie a obnovu údajov systému. Bežné aplikácie toto nastavenie nepoužívajú."</string>
    <string name="permlab_confirm_full_backup" msgid="5557071325804469102">"potvrdenie operácie úplnej zálohy alebo úplného obnovenia"</string>
    <string name="permdesc_confirm_full_backup" msgid="1748762171637699562">"Umožňuje aplikácii spustiť používateľské rozhranie potvrdenia úplnej zálohy. Toto nastavenie by nemala používať žiadna aplikácia."</string>
    <string name="permlab_internalSystemWindow" msgid="2148563628140193231">"zobrazenie neoprávnených okien"</string>
    <string name="permdesc_internalSystemWindow" msgid="7458387759461466397">"Umožňuje aplikácii vytvárať okná, ktoré majú byť použité interným systémom používateľského rozhrania. Bežné aplikácie toto nastavenie nepoužívajú."</string>
    <string name="permlab_systemAlertWindow" msgid="3543347980839518613">"vykresliť cez ďalšie aplikácie"</string>
    <string name="permdesc_systemAlertWindow" msgid="8584678381972820118">"Umožňuje aplikáciu vykresľovanie nad inými aplikáciami alebo súčasťami používateľského rozhrania. Táto funkcia môže zasahovať do vášho používania rozhrania inej aplikácie alebo meniť zobrazovaný obsah v iných aplikáciách."</string>
    <string name="permlab_setAnimationScale" msgid="2805103241153907174">"globálne zmeny rýchlosti animácie"</string>
    <string name="permdesc_setAnimationScale" msgid="7690063428924343571">"Umožňuje aplikácii kedykoľvek globálne zmeniť rýchlosť animácie (rýchlejšia alebo pomalšia animácia)."</string>
    <string name="permlab_manageAppTokens" msgid="1286505717050121370">"spravovať tokeny aplikácií"</string>
    <string name="permdesc_manageAppTokens" msgid="8043431713014395671">"Umožňuje aplikácii vytvárať a spravovať svoje vlastné tokeny a obísť ich obvyklé Z-usporiadanie. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_freezeScreen" msgid="4708181184441880175">"zmraziť obrazovku"</string>
    <string name="permdesc_freezeScreen" msgid="8558923789222670064">"Umožňuje aplikácii dočasne zmraziť obrazovku na prechod v režime celej obrazovky."</string>
    <string name="permlab_injectEvents" msgid="1378746584023586600">"používanie kláves a tlačidiel"</string>
    <string name="permdesc_injectEvents" product="tablet" msgid="206352565599968632">"Umožňuje aplikácii doručiť vlastné udalosti vstupu (stlačenie tlačidiel atď.) ďalším aplikáciám. Škodlivé aplikácie môžu pomocou toho prevziať kontrolu nad tabletom."</string>
    <string name="permdesc_injectEvents" product="default" msgid="653128057572326253">"Umožňuje aplikácii doručiť vlastné udalosti vstupu (stlačenie tlačidiel atď.) ďalším aplikáciám. Škodlivé aplikácie môžu pomocou tohto nastavenia prevziať kontrolu nad telefónom."</string>
    <string name="permlab_readInputState" msgid="469428900041249234">"zaznamenanie písaného textu a realizovaných akcií"</string>
    <string name="permdesc_readInputState" msgid="8387754901688728043">"Umožňuje aplikácii sledovať, ktoré klávesy stlačíte, dokonca aj keď pracujete s inou aplikáciou (napr. zadávanie hesla). Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_bindInputMethod" msgid="3360064620230515776">"väzba na metódu vstupu"</string>
    <string name="permdesc_bindInputMethod" msgid="3250440322807286331">"Umožňuje držiteľovi viazať sa na najvyššiu úroveň rozhrania metódy vstupu. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_bindAccessibilityService" msgid="5357733942556031593">"viazať na službu zjednodušeného ovládania"</string>
    <string name="permdesc_bindAccessibilityService" msgid="7034615928609331368">"Umožňuje držiteľovi viazať sa na najvyššiu úroveň rozhrania služby zjednodušeného ovládania. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_bindTextService" msgid="7358378401915287938">"väzba na textovú službu"</string>
    <string name="permdesc_bindTextService" msgid="8151968910973998670">"Umožňuje držiteľovi viazať sa na najvyššiu úroveň rozhrania textovej služby (napr. SpellCheckerService). Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_bindVpnService" msgid="4708596021161473255">"Zaviazať k službe VPN"</string>
    <string name="permdesc_bindVpnService" msgid="2067845564581693905">"Umožňuje držiteľovi viazať sa na najvyššiu úroveň rozhrania služby VPN. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_bindWallpaper" msgid="8716400279937856462">"väzba na tapetu"</string>
    <string name="permdesc_bindWallpaper" msgid="7108428692595491668">"Umožňuje držiteľovi viazať sa na najvyššiu úroveň rozhrania tapety. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_bindRemoteViews" msgid="5697987759897367099">"viazať sa k službe miniaplikácie"</string>
    <string name="permdesc_bindRemoteViews" msgid="4717987810137692572">"Umožňuje držiteľovi viazať sa na najvyššiu úroveň rozhrania služby miniaplikácií. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_bindDeviceAdmin" msgid="8704986163711455010">"komunikovať so správcom zariadenia"</string>
    <string name="permdesc_bindDeviceAdmin" msgid="569715419543907930">"Umožňuje držiteľovi odosielať informácie správcovi zariadenia. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_setOrientation" msgid="3365947717163866844">"zmena orientácie obrazovky"</string>
    <string name="permdesc_setOrientation" msgid="3046126619316671476">"Umožňuje aplikácii kedykoľvek zmeniť otáčanie obrazovky. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_setPointerSpeed" msgid="9175371613322562934">"zmena rýchlosti ukazovateľa"</string>
    <string name="permdesc_setPointerSpeed" msgid="6866563234274104233">"Umožňuje aplikácii kedykoľvek zmeniť rýchlosť kurzora myši alebo touchpadu. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_setKeyboardLayout" msgid="4778731703600909340">"zmeniť rozloženie klávesnice"</string>
    <string name="permdesc_setKeyboardLayout" msgid="8480016771134175879">"Umožňuje aplikácii zmeniť rozloženie klávesnice. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_signalPersistentProcesses" msgid="4539002991947376659">"odoslať aplikáciám signály systému Linux"</string>
    <string name="permdesc_signalPersistentProcesses" msgid="4896992079182649141">"Umožňuje aplikácii vyžiadať odoslanie poskytnutého signálu všetkým trvalým procesom."</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="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_deletePackages" msgid="184385129537705938">"odstrániť aplikácie"</string>
    <string name="permdesc_deletePackages" msgid="7411480275167205081">"Umožňuje aplikácii odstrániť balíky systému Android. Škodlivé aplikácie môžu použiť toto nastavenie na odstránenie dôležitých aplikácií."</string>
    <string name="permlab_clearAppUserData" msgid="274109191845842756">"odstrániť údaje iných aplikácií"</string>
    <string name="permdesc_clearAppUserData" msgid="4625323684125459488">"Umožňuje aplikácii vymazať údaje používateľa."</string>
    <string name="permlab_deleteCacheFiles" msgid="3128665571837408675">"odstrániť vyrovnávacie pamäte iných aplikácií"</string>
    <string name="permdesc_deleteCacheFiles" msgid="3812998599006730196">"Umožňuje aplikácii odstrániť súbory vyrovnávacej pamäte."</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_installPackages" msgid="2199128482820306924">"priamo inštalovať aplikácie"</string>
    <string name="permdesc_installPackages" msgid="5628530972548071284">"Umožňuje aplikácii nainštalovať nové alebo aktualizované balíky systému Android. Škodlivé aplikácie môžu použiť toto nastavenie na pridanie nových aplikácií s ľubovoľnými povoleniami."</string>
    <string name="permlab_clearAppCache" msgid="7487279391723526815">"odstrániť všetky údaje vyrovnávacej pamäte aplikácie"</string>
    <string name="permdesc_clearAppCache" product="tablet" msgid="8974640871945434565">"Umožňuje aplikácii uvoľniť ukladací priestor v tablete odstránením súborov v adresároch iných aplikácií vo vyrovnávacej pamäti. To môže viesť k pomalšiemu spúšťaniu iných aplikácií, pretože musia znovu načítať svoje údaje."</string>
    <string name="permdesc_clearAppCache" product="default" msgid="2459441021956436779">"Umožňuje aplikácii uvoľniť ukladací priestor v telefóne odstránením súborov v adresároch iných aplikácií vo vyrovnávacej pamäti. To môže viesť k pomalšiemu spúšťaniu iných aplikácií, pretože musia znovu načítať svoje údaje."</string>
    <string name="permlab_movePackage" msgid="3289890271645921411">"presúvať prostriedky aplikácií"</string>
    <string name="permdesc_movePackage" msgid="319562217778244524">"Umožňuje aplikácii presúvať prostriedky aplikácií medzi internými a externými médiami."</string>
    <string name="permlab_readLogs" msgid="6615778543198967614">"čítať citlivé údaje denníkov"</string>
    <string name="permdesc_readLogs" product="tablet" msgid="82061313293455151">"Umožňuje aplikácii čítať rôzne systémové súbory denníkov. Toto nastavenie aplikácie umožňuje získať všeobecné informácie o činnostiach s tabletom, ktoré by mohli obsahovať osobné alebo súkromné informácie."</string>
    <string name="permdesc_readLogs" product="default" msgid="2063438140241560443">"Umožňuje aplikácii čítať rôzne systémové súbory denníkov. Toto nastavenie aplikácii umožňuje získať všeobecné informácie o činnostiach s telefónom, ktoré by mohli obsahovať osobné alebo súkromné informácie."</string>
    <string name="permlab_anyCodecForPlayback" msgid="715805555823881818">"použiť ľubovoľný dekódovač médií na reprodukciu"</string>
    <string name="permdesc_anyCodecForPlayback" msgid="8283912488433189010">"Umožňuje aplikácii používať na reprodukciu ľubovoľný nainštalovaný dekódovač na dekódovanie."</string>
    <string name="permlab_diagnostic" msgid="8076743953908000342">"čítanie alebo zápis do prostriedkov funkcie diag"</string>
    <string name="permdesc_diagnostic" msgid="6608295692002452283">"Umožňuje aplikácii čítať ľubovoľné prostriedky v skupine diag, napr. súbory v priečinku /dev, a zapisovať do nich. Môže dôjsť k ovplyvneniu stability a bezpečnosti systému. Toto nastavenie by mal používať IBA výrobca či operátor na diagnostiku hardvéru."</string>
    <string name="permlab_changeComponentState" msgid="6335576775711095931">"povoliť alebo zakázať súčasti aplikácie"</string>
    <string name="permdesc_changeComponentState" product="tablet" msgid="8887435740982237294">"Umožňuje aplikácii zmeniť to, či je súčasť inej aplikácie povolená alebo zakázaná. Škodlivé aplikácie môžu pomocou tohto nastavenia zakázať dôležité funkcie tabletu. S týmto povolením musíte zaobchádzať opatrne, pretože súčasti aplikácie môžete dostať do nepoužiteľného, nekonzistentného alebo nestabilného stavu."</string>
    <string name="permdesc_changeComponentState" product="default" msgid="1827232484416505615">"Umožňuje aplikácii zmeniť to, či je súčasť inej aplikácie povolená alebo zakázaná. Škodlivé aplikácie môžu pomocou tohto nastavenia zakázať dôležité funkcie telefónu. S týmto povolením musíte zaobchádzať opatrne, pretože súčasti aplikácie môžete dostať do nepoužiteľného, nekonzistentného alebo nestabilného stavu."</string>
    <string name="permlab_grantRevokePermissions" msgid="4627315351093508795">"povoliť alebo zakázať povolenia"</string>
    <string name="permdesc_grantRevokePermissions" msgid="4088642654085850662">"Umožňuje aplikácii povoliť alebo zakázať konkrétne povolenia pre seba alebo iné aplikácie. Škodlivé aplikácie môžu použiť túto možnosť na pristupovanie k funkciám, ktoré ste im nepovolili."</string>
    <string name="permlab_setPreferredApplications" msgid="8463181628695396391">"nastaviť preferované aplikácie"</string>
    <string name="permdesc_setPreferredApplications" msgid="4973986762241783712">"Umožňuje aplikácii zmeniť vaše preferované aplikácie. Škodlivé aplikácie môžu v tichosti zmeniť spustené aplikácie a oklamať existujúce aplikácie, aby zhromažďovali vaše súkromné údaje."</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_writeSecureSettings" msgid="204676251876718288">"zmeny zabezpečených nastavení systému"</string>
    <string name="permdesc_writeSecureSettings" msgid="8159535613020137391">"Umožňuje aplikácii zmeniť údaje o bezpečnostných nastaveniach systému. Bežné aplikácie toto nastavenie nepoužívajú."</string>
    <string name="permlab_writeGservices" msgid="2149426664226152185">"zmeny mapy služieb Google"</string>
    <string name="permdesc_writeGservices" msgid="1287309437638380229">"Umožňuje aplikácii upraviť mapu služieb Google. Bežné aplikácie toto nastavenie nepoužívajú."</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="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="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="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="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" product="tablet" msgid="3700645184870760285">"Umožňuje aplikácii čítať denník hovorov vášho tabletu vrátane údajov o prichádzajúcich a odchádzajúcich hovoroch. Toto povolenie umožňuje aplikáciám ukladať údaje o hovoroch. Škodlivé aplikácie môžu zdieľať údaje o hovoroch bez vášho vedomia."</string>
    <string name="permdesc_readCallLog" product="default" msgid="5777725796813217244">"Umožňuje aplikácii čítať denník hovorov vášho telefónu vrátane údajov o prichádzajúcich a odchádzajúcich hovoroch. Toto povolenie umožňuje aplikáciám ukladať údaje o hovoroch. Škodlivé aplikácie môžu zdieľať údaje o hovoroch bez vášho vedomia."</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="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_readProfile" msgid="4701889852612716678">"čítať vlastnú kartu kontaktu"</string>
    <string name="permdesc_readProfile" product="default" msgid="5462475151849888848">"Umožňuje aplikácii čítať informácie v osobnom profile uložené v zariadení, ako je vaše meno a kontaktné informácie. Znamená to, že vás ostatné aplikácie môžu identifikovať a odoslať informácie o vašom profile iným aplikáciám."</string>
    <string name="permlab_writeProfile" msgid="907793628777397643">"upraviť vlastnú kartu kontaktu"</string>
    <string name="permdesc_writeProfile" product="default" msgid="5552084294598465899">"Umožňuje aplikácii zmeniť alebo pridať do osobného profilu informácie uložené vo vašom zariadení, ako je vaše meno a kontaktné informácie. Znamená to, že vás aplikácia môže identifikovať a odoslať informácie o vašom profile ostatným aplikáciám."</string>
    <string name="permlab_readSocialStream" product="default" msgid="1268920956152419170">"čítať váš sociálny stream"</string>
    <string name="permdesc_readSocialStream" product="default" msgid="4255706027172050872">"Umožňuje aplikácii pristupovať k sociálnym aktualizáciám od vás a vašich priateľov a synchronizovať ich. Pri zdieľaní informácií dávajte pozor – toto povolenie umožňuje aplikácii čítať komunikáciu medzi vami a vašimi priateľmi v sociálnych sieťach, a to bez ohľadu na jej dôvernosť. Poznámka: Toto povolenie nie je možné vynucovať v prípade všetkých sociálnych sietí."</string>
    <string name="permlab_writeSocialStream" product="default" msgid="3504179222493235645">"písať do vášho sociálneho streamu"</string>
    <string name="permdesc_writeSocialStream" product="default" msgid="3086557552204114849">"Umožňuje aplikácii zobraziť sociálne aktualizácie od vašich priateľov. Pri zdieľaní informácií dávajte pozor – toto povolenie umožňuje aplikácii vytvárať správy, ktoré zdanlivo pochádzajú od vašich priateľov. Poznámka: Toto povolenie nie je možné vynucovať v prípade všetkých sociálnych sietí."</string>
    <string name="permlab_readCalendar" msgid="5972727560257612398">"čítať udalosti v kalendári a dôverné informácie"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="4216462049057658723">"Umožňuje aplikácii čítať všetky udalosti kalendára uložené v tablete vrátane udalostí priateľov alebo spolupracovníkov. Aplikácii to umožní zdieľať alebo ukladať údaje kalendára bez ohľadu na dôvernosť či citlivosť týchto údajov."</string>
    <string name="permdesc_readCalendar" product="default" msgid="7434548682470851583">"Umožňuje aplikácii čítať všetky udalosti kalendára uložené v telefóne vrátane udalostí priateľov alebo spolupracovníkov. Aplikácii to umožní zdieľať alebo ukladať údaje kalendára bez ohľadu na dôvernosť či citlivosť týchto údajov."</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="6679035520113668528">"Umožňuje aplikácii pridávať, odstraňovať alebo meniť udalosti, ktoré môžete v tablete upravovať, a to vrátane udalostí priateľov a spolupracovníkov. Toto povolenie umožňuje aplikácii odosielať správy, ktoré budú zdanlivo prichádzať od vlastníkov kalendára, alebo upravovať udalosti bez vedomia vlastníkov."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="2324469496327249376">"Umožňuje aplikácii pridávať, odstraňovať alebo meniť udalosti, ktoré môžete v telefóne upravovať, a to vrátane udalostí priateľov a spolupracovníkov. Toto povolenie umožňuje aplikácii odosielať správy, ktoré budú zdanlivo prichádzať od vlastníkov kalendára, alebo upravovať udalosti bez vedomia vlastníkov."</string>
    <string name="permlab_accessMockLocation" msgid="8688334974036823330">"simulácia zdrojov polohy na účely testovania"</string>
    <string name="permdesc_accessMockLocation" msgid="5808711039482051824">"Vytváranie simulovaných zdrojov polohy na testovanie alebo inštalácia nového poskytovateľa informácií o polohe. Aplikácii to umožní nahradiť polohu a stav, ktoré vracajú iné zdroje informácií o polohe, ako sú napríklad systém GPS alebo poskytovatelia informácií o polohe."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"prístup k ďalším príkazom poskytovateľa polohy"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="5945166642335800763">"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_installLocationProvider" msgid="6578101199825193873">"Oprávnenie na inštaláciu poskytovateľa polohy"</string>
    <string name="permdesc_installLocationProvider" msgid="9066146120470591509">"Vytváranie simulovaných zdrojov polohy na testovanie alebo inštalácia nového poskytovateľa informácií o polohe. Aplikácii to umožní nahradiť polohu a stav, ktoré vracajú iné zdroje informácií o polohe, ako sú napríklad systém GPS alebo poskytovatelia informácií o polohe."</string>
    <string name="permlab_accessFineLocation" msgid="1191898061965273372">"presná poloha (pomocou GPS a siete)"</string>
    <string name="permdesc_accessFineLocation" msgid="5295047563564981250">"Umožňuje aplikácii získať vašu presnú polohu pomocou systému GPS (Global Positioning System) alebo zdrojov určenia polohy siete, napríklad mobilných veží a sietí Wi-Fi. Tieto služby využívajúce polohu musia byť na vašom zariadení zapnuté a dostupné, inak ich aplikácia nebude môcť využívať. Aplikácie môžu tieto služby využívať na určenie vašej polohy. Tieto služby môžu zvýšiť spotrebu batérie."</string>
    <string name="permlab_accessCoarseLocation" msgid="4887895362354239628">"približná poloha (pomocou siete)"</string>
    <string name="permdesc_accessCoarseLocation" msgid="2538200184373302295">"Umožňuje aplikácii získať vašu približnú polohu. Táto poloha je odvodená zo služieb využívajúcich polohu pomocou zdrojov určenia polohy siete, napríklad mobilných veží a sietí Wi-Fi. Tieto služby využívajúce polohu musia byť na vašom zariadení zapnuté a dostupné, inak ich aplikácia nebude môcť využívať. Aplikácie môžu tieto služby využívať na určenie vašej približnej polohy."</string>
    <string name="permlab_accessSurfaceFlinger" msgid="2363969641792388947">"prístup k službe SurfaceFlinger"</string>
    <string name="permdesc_accessSurfaceFlinger" msgid="1041619516733293551">"Umožňuje aplikácii používať funkcie nízkej úrovne aplikácie SurfaceFlinger."</string>
    <string name="permlab_readFrameBuffer" msgid="6690504248178498136">"čítanie vyrovnávacej pamäte snímok"</string>
    <string name="permdesc_readFrameBuffer" msgid="4937405521809454680">"Umožňuje aplikácii čítať obsah vyrovnávacej pamäte snímok."</string>
    <string name="permlab_configureWifiDisplay" msgid="5595661694746742168">"konfigurovať displeje cez sieť Wi-Fi"</string>
    <string name="permdesc_configureWifiDisplay" msgid="7916815158690218065">"Umožňuje aplikácii konfigurovať displeje a pripojiť sa k nim cez siete Wi-Fi."</string>
    <string name="permlab_controlWifiDisplay" msgid="393641276723695496">"ovládať displeje cez sieť Wi-Fi"</string>
    <string name="permdesc_controlWifiDisplay" msgid="4543912292681826986">"Umožňuje aplikácii ovládať základné funkcie displejov cez siete Wi-Fi."</string>
    <string name="permlab_modifyAudioSettings" msgid="6095859937069146086">"zmeny vašich nastavení 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">"záznam zvuku"</string>
    <string name="permdesc_recordAudio" msgid="4906839301087980680">"Umožňuje aplikácii zaznamenávať zvuk pomocou mikrofónu. Toto povolenie umožňuje aplikácii zaznamenávať zvuk kedykoľvek bez vášho potvrdenia."</string>
    <string name="permlab_camera" msgid="3616391919559751192">"snímanie fotografií a natáčanie videí"</string>
    <string name="permdesc_camera" msgid="8497216524735535009">"Umožňuje aplikácii fotografovať a nahrávať videá pomocou fotoaparátu. Toto povolenie umožňuje aplikácii používať fotoaparát kedykoľvek a bez vášho potvrdenia."</string>
    <string name="permlab_cameraDisableTransmitLed" msgid="2651072630501126222">"Zakázať indikátor LED prenosu pri používaní fotoaparátu"</string>
    <string name="permdesc_cameraDisableTransmitLed" msgid="4764585465480295341">"Umožňuje v predinštalovanej systémovej aplikácii zakázať indikátor LED používania fotoaparátu."</string>
    <string name="permlab_brick" product="tablet" msgid="2961292205764488304">"trvalé zakázanie tabletu"</string>
    <string name="permlab_brick" product="default" msgid="8337817093326370537">"trvalé vypnutie telefónu"</string>
    <string name="permdesc_brick" product="tablet" msgid="4334818808001699530">"Umožňuje aplikácii natrvalo zakázať celý tablet. Toto je veľmi nebezpečné nastavenie."</string>
    <string name="permdesc_brick" product="default" msgid="5788903297627283099">"Umožňuje aplikácii natrvalo zakázať celý telefón. Ide o veľmi nebezpečné nastavenie."</string>
    <string name="permlab_reboot" product="tablet" msgid="3436634972561795002">"vynútené reštartovanie tabletu"</string>
    <string name="permlab_reboot" product="default" msgid="2898560872462638242">"vynútenie reštartovania telefónu"</string>
    <string name="permdesc_reboot" product="tablet" msgid="8172056180063700741">"Umožňuje aplikácii vynútiť reštartovanie tabletu."</string>
    <string name="permdesc_reboot" product="default" msgid="5326008124289989969">"Umožňuje aplikácii vynútiť reštartovanie telefónu."</string>
    <string name="permlab_mount_unmount_filesystems" product="nosdcard" msgid="2927361537942591841">"pristup. do systému súbor. USB"</string>
    <string name="permlab_mount_unmount_filesystems" product="default" msgid="4402305049890953810">"pristupovať do systému súborov karty SD"</string>
    <string name="permdesc_mount_unmount_filesystems" msgid="1829290701658992347">"Umožňuje aplikácii pripojiť a odpojiť súborové systémy vo vymeniteľných ukladacích priestoroch."</string>
    <string name="permlab_mount_format_filesystems" product="nosdcard" msgid="6227819582624904972">"vymazať ukladací priestor USB"</string>
    <string name="permlab_mount_format_filesystems" product="default" msgid="262582698639274056">"vymazať kartu SD"</string>
    <string name="permdesc_mount_format_filesystems" msgid="8784268246779198627">"Umožňuje aplikácii formátovať vymeniteľný ukladací priestor."</string>
    <string name="permlab_asec_access" msgid="3411338632002193846">"získať informácie o internom ukladacom priestore"</string>
    <string name="permdesc_asec_access" msgid="3094563844593878548">"Umožňuje aplikácii získať informácie o internom ukladacom priestore."</string>
    <string name="permlab_asec_create" msgid="6414757234789336327">"vytvoriť interný ukladací priestor"</string>
    <string name="permdesc_asec_create" msgid="4558869273585856876">"Umožňuje aplikácii vytvoriť interný ukladací priestor."</string>
    <string name="permlab_asec_destroy" msgid="526928328301618022">"zničiť interný ukladací priestor"</string>
    <string name="permdesc_asec_destroy" msgid="7218749286145526537">"Umožňuje aplikácii zničiť interný ukladací priestor."</string>
    <string name="permlab_asec_mount_unmount" msgid="8877998101944999386">"pripojiť alebo odpojiť interný ukladací priestor"</string>
    <string name="permdesc_asec_mount_unmount" msgid="3451360114902490929">"Umožňuje aplikácii pripojiť alebo odpojiť interný ukladací priestor."</string>
    <string name="permlab_asec_rename" msgid="7496633954080472417">"premenovať interný ukladací priestor"</string>
    <string name="permdesc_asec_rename" msgid="1794757588472127675">"Umožňuje aplikácii premenovať interný ukladací priestor."</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_flashlight" msgid="2155920810121984215">"ovládanie kontrolky"</string>
    <string name="permdesc_flashlight" msgid="6522284794568368310">"Umožňuje aplikácii ovládať svetlo."</string>
    <string name="permlab_manageUsb" msgid="1113453430645402723">"spravovať predvoľby a povolenia zariadení USB"</string>
    <string name="permdesc_manageUsb" msgid="7776155430218239833">"Umožňuje aplikácii spravovať predvoľby a povolenia zariadení USB."</string>
    <string name="permlab_accessMtp" msgid="4953468676795917042">"implementovať protokol MTP"</string>
    <string name="permdesc_accessMtp" msgid="6532961200486791570">"Povoľuje prístup k ovládaču kernel MTP na implementáciu protokolu MTP USB."</string>
    <string name="permlab_hardware_test" msgid="4148290860400659146">"testovanie hardvéru"</string>
    <string name="permdesc_hardware_test" msgid="6597964191208016605">"Umožňuje aplikácii ovládať rôzne periférie na účely testovania hardvéru."</string>
    <string name="permlab_callPhone" msgid="3925836347681847954">"priame volanie na telefónne čísla"</string>
    <string name="permdesc_callPhone" msgid="3740797576113760827">"Umožňuje aplikácii volať telefónne čísla bez vášho zásahu. V dôsledku toho sa môžu účtovať neočakávané poplatky alebo sa môžu uskutočniť neočakávané hovory. Toto povolenie neumožňuje aplikácii volať na čísla tiesňového volania."</string>
    <string name="permlab_callPrivileged" msgid="4198349211108497879">"priame volanie na ľubovoľné telefónne čísla"</string>
    <string name="permdesc_callPrivileged" msgid="1689024901509996810">"Umožňuje aplikácii volať na akékoľvek telefónne číslo (bez vášho zásahu) vrátane čísiel tiesňového volania. Škodlivé aplikácie môžu uskutočňovať zbytočné a nezákonné volania na tiesňové linky."</string>
    <string name="permlab_performCdmaProvisioning" product="tablet" msgid="4842576994144604821">"priamo spustiť nastavenie tabletu CDMA"</string>
    <string name="permlab_performCdmaProvisioning" product="default" msgid="5604848095315421425">"priamo spustiť nastavenie telefónu CDMA"</string>
    <string name="permdesc_performCdmaProvisioning" msgid="1994193538802314186">"Umožňuje aplikácii spustiť poskytovanie CDMA. Škodlivé aplikácie môžu spustiť poskytovanie CDMA samovoľne."</string>
    <string name="permlab_locationUpdates" msgid="7785408253364335740">"ovládanie upozornení na aktualizáciu polohy"</string>
    <string name="permdesc_locationUpdates" msgid="1120741557891438876">"Umožňuje aplikácii povoliť alebo zakázať upozornenia s aktualizáciami polohy z rádia. Bežné aplikácie toto nastavenie nepoužívajú."</string>
    <string name="permlab_checkinProperties" msgid="7855259461268734914">"prístup k vlastnostiam nahlásenia"</string>
    <string name="permdesc_checkinProperties" msgid="4024526968630194128">"Umožňuje aplikácii čítať a zapisovať vlastnosti odovzdané službou nahlasovania. Bežné aplikácie toto nastavenie nepoužívajú."</string>
    <string name="permlab_bindGadget" msgid="776905339015863471">"zvoliť miniaplikácie"</string>
    <string name="permdesc_bindGadget" msgid="8261326938599049290">"Umožňuje aplikácii povedať systému, ktoré aplikácie môžu používať určité miniaplikácie. Aplikácia s týmto povolením môže iným aplikáciám povoliť prístup k osobným údajom. Bežné aplikácie toto nastavenie nepoužívajú."</string>
    <string name="permlab_modifyPhoneState" msgid="8423923777659292228">"zmeny stavu telefónu"</string>
    <string name="permdesc_modifyPhoneState" msgid="1029877529007686732">"Umožňuje aplikácii ovládať telefónne funkcie zariadenia. Aplikácia s týmto povolením môže prepínať siete alebo zapnúť a vypnúť rádio bez toho, aby vás na to upozornila."</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_wakeLock" product="tablet" msgid="1531731435011495015">"zabránenie prechodu tabletu do režimu spánku"</string>
    <string name="permlab_wakeLock" product="default" msgid="573480187941496130">"zabránenie prechodu telefónu do režimu 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="default" msgid="8559100677372928754">"Umožňuje aplikácii zabrániť prechodu telefónu do režimu spánku."</string>
    <string name="permlab_devicePower" product="tablet" msgid="2787034722616350417">"zapnutie a vypnutie tabletu"</string>
    <string name="permlab_devicePower" product="default" msgid="4928622470980943206">"zapnutie a vypnutie telefónu"</string>
    <string name="permdesc_devicePower" product="tablet" msgid="6689862878984631831">"Umožňuje aplikácii zapnúť a vypnúť tablet."</string>
    <string name="permdesc_devicePower" product="default" msgid="6037057348463131032">"Umožňuje aplikácii zapnúť a vypnúť telefón."</string>
    <string name="permlab_factoryTest" msgid="3715225492696416187">"spustenie v režime továrenského testu"</string>
    <string name="permdesc_factoryTest" product="tablet" msgid="3952059318359653091">"Umožňuje aplikácii spustenie v režime nízkoúrovňového testu výrobcu a povolí úplný prístup k hardvéru tabletu. K dispozícii iba vtedy, keď je tablet spustený v režime testovania výrobcu."</string>
    <string name="permdesc_factoryTest" product="default" msgid="8136644990319244802">"Umožňuje aplikácii spustenie v režime nízkoúrovňového testu výrobcu a povolí úplný prístup k hardvéru telefónu. K dispozícii iba vtedy, keď je telefón spustený v režime testovania výrobcu."</string>
    <string name="permlab_setWallpaper" msgid="6627192333373465143">"nastavenie tapety"</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_masterClear" msgid="2315750423139697397">"obnovenie továrenských nastavení systému"</string>
    <string name="permdesc_masterClear" msgid="3665380492633910226">"Umožňuje aplikácii úplne obnoviť továrenské nastavenia systému a vymazať všetky údaje, konfiguráciu a nainštalované aplikácie."</string>
    <string name="permlab_setTime" msgid="2021614829591775646">"nastaviť čas"</string>
    <string name="permdesc_setTime" product="tablet" msgid="1896341438151152881">"Umožňuje aplikácii zmeniť časové pásmo tabletu."</string>
    <string name="permdesc_setTime" product="default" msgid="1855702730738020">"Umožňuje aplikácii zmeniť čas hodín v telefóne."</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="default" msgid="4499943488436633398">"Umožňuje aplikácii zmeniť časové pásmo telefónu."</string>
    <string name="permlab_accountManagerService" msgid="4829262349691386986">"rola služby AccountManagerService"</string>
    <string name="permdesc_accountManagerService" msgid="1948455552333615954">"Umožňuje aplikácii volať funkcie AccountAuthenticator."</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="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_authenticateAccounts" msgid="5265908481172736933">"vytvoriť účty a nastaviť heslá"</string>
    <string name="permdesc_authenticateAccounts" msgid="5472124296908977260">"Umožňuje aplikácii využiť možnosti overovania účtu aplikácie AccountManager vrátane vytvárania účtov a získavania a nastavovania ich hesiel."</string>
    <string name="permlab_manageAccounts" msgid="4983126304757177305">"pridať alebo odstrániť účty"</string>
    <string name="permdesc_manageAccounts" msgid="8698295625488292506">"Umožňuje aplikácii uskutočňovať operácie, ako je pridávanie alebo odstraňovanie účtov alebo odstraňovanie ich hesiel."</string>
    <string name="permlab_useCredentials" msgid="235481396163877642">"používať účty na zariadení"</string>
    <string name="permdesc_useCredentials" msgid="7984227147403346422">"Umožňuje aplikácii vyžiadať overovacie tokeny."</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="8018758136404323658">"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_writeApnSettings" msgid="505660159675751896">"meniť/zachytávať nastavenia siete a sieťové prenosy"</string>
    <string name="permdesc_writeApnSettings" msgid="5333798886412714193">"Umožňuje aplikácii zmeniť nastavenia siete a zachytiť a kontrolovať celé sieťové prenosy (napr. zmenu proxy a portu akéhokoľvek APN). Škodlivé aplikácie môžu sledovať, presmerovať alebo meniť sieťové pakety bez vášho vedomia."</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_changeBackgroundDataSetting" msgid="1400666012671648741">"zmeniť nastavenie použitia údajov na pozadí"</string>
    <string name="permdesc_changeBackgroundDataSetting" msgid="5347729578468744379">"Umožňuje aplikácii zmeniť nastavenie používania údajov na pozadí."</string>
    <string name="permlab_accessWifiState" msgid="5202012949247040011">"zobraziť pripojenia siete 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 viacsmerového vysielania Wi-Fi"</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="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="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="2405042267131496579">"Zmeniť stav siete 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="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="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 Near Field Communication"</string>
    <string name="permdesc_nfc" msgid="7120611819401789907">"Umožňuje aplikácii komunikovať so značkami, kartami a čítačkami s podporou technológie Near Field Communication (NFC)."</string>
    <string name="permlab_disableKeyguard" msgid="3598496301486439258">"zakázať uzamknutie 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_readSyncSettings" msgid="6201810008230503052">"čítanie nastavení 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">"prepínať nastavenie synchronizácie medzi hodnotou zapnuté a vypnuté"</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">"čítanie štatistických údajov 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_subscribedFeedsRead" msgid="4756609637053353318">"čítanie zdrojov prihlásených na odber"</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_subscribedFeedsWrite" msgid="9015246325408209296">"zápis odoberaných zdrojov"</string>
    <string name="permdesc_subscribedFeedsWrite" msgid="6928930188826089413">"Umožňuje aplikácii upraviť vaše aktuálne synchronizované informačné kanály. Škodlivé aplikácie môžu synchronizované informačné kanály zmeniť."</string>
    <string name="permlab_readDictionary" msgid="4107101525746035718">"čítať výrazy pridané do slovníka"</string>
    <string name="permdesc_readDictionary" msgid="659614600338904243">"Umožňuje aplikácii čítať všetky slová, názvy a frázy, ktoré mohol používateľ uložiť do svojho slovníka."</string>
    <string name="permlab_writeDictionary" msgid="2183110402314441106">"pridať slová do slovníka definovaného používateľom"</string>
    <string name="permdesc_writeDictionary" msgid="8185385716255065291">"Umožňuje aplikácii zapisovať nové slová do používateľského slovníka."</string>
    <string name="permlab_sdcardRead" product="nosdcard" msgid="8235341515605559677">"testovanie prístupu do chráneného ukladacieho priestoru"</string>
    <string name="permlab_sdcardRead" product="default" msgid="8235341515605559677">"testovanie prístupu do chráneného ukladacieho priestoru"</string>
    <string name="permdesc_sdcardRead" product="nosdcard" msgid="3642473292348132072">"Umožňuje aplikácii testovať povolenie pre úložisko USB, ktoré bude k dispozícii na zariadeniach."</string>
    <string name="permdesc_sdcardRead" product="default" msgid="5914402684685848828">"Umožňuje aplikácii testovať povolenie pre kartu SD, ktorá bude k dispozícii v budúcich zariadeniach."</string>
    <string name="permlab_sdcardWrite" product="nosdcard" msgid="8485979062254666748">"upraviť alebo odstrániť obsah úložiska USB"</string>
    <string name="permlab_sdcardWrite" product="default" msgid="8805693630050458763">"úprava alebo odstránenie obsahu na karte SD"</string>
    <string name="permdesc_sdcardWrite" product="nosdcard" msgid="6175406299445710888">"Umožňuje aplikácii zápis do ukladacieho priestoru USB."</string>
    <string name="permdesc_sdcardWrite" product="default" msgid="4337417790936632090">"Umožňuje aplikácii zápis na kartu SD."</string>
    <string name="permlab_mediaStorageWrite" product="default" msgid="6859839199706879015">"úprava alebo odstránenie obsahu interného ukladacieho priestoru média"</string>
    <string name="permdesc_mediaStorageWrite" product="default" msgid="8189160597698529185">"Umožňuje aplikácii zmeniť obsah interného ukladacieho priestoru média."</string>
    <string name="permlab_sdcardAccessAll" msgid="8150613823900460576">"pristupovať k externému ukladaciemu priestoru pre všetkých používateľov"</string>
    <string name="permdesc_sdcardAccessAll" msgid="3215208357415891320">"Umožňuje aplikácii pristupovať k externému ukladaciemu priestoru pre všetkých používateľov."</string>
    <string name="permlab_cache_filesystem" msgid="5656487264819669824">"pristupovať do súborového systému vyrovnávacej pamäte"</string>
    <string name="permdesc_cache_filesystem" msgid="5578967642265550955">"Umožňuje aplikácii čítať a zapisovať do súborového systému vyrovnávacej pamäte."</string>
    <string name="permlab_use_sip" msgid="5986952362795870502">"uskutočňovať a prijímať internetové hovory"</string>
    <string name="permdesc_use_sip" msgid="4717632000062674294">"Umožňuje aplikácii uskutočniť a prijímať internetové hovory pomocou služby SIP."</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="policylab_limitPassword" msgid="4497420728857585791">"Nastaviť pravidlá pre heslo"</string>
    <string name="policydesc_limitPassword" msgid="3252114203919510394">"Ovládanie dĺžky hesiel na odomknutie obrazovky a v nich používané znaky."</string>
    <string name="policylab_watchLogin" msgid="914130646942199503">"Sledovať pokusy 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="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="policylab_resetPassword" msgid="2620077191242688955">"Zmeniť heslo na odomknutie obrazovky"</string>
    <string name="policydesc_resetPassword" msgid="605963962301904458">"Zmena hesla na odomknutie 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">"Vymazanie všetkých údajov"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="4306184096067756876">"Bez predchádzajúceho upozornenia zmazať všetky údaje tým, že sa obnovia továrenské nastavenia tabletu."</string>
    <string name="policydesc_wipeData" product="default" msgid="5096895604574188391">"Bez predchádzajúceho upozornenia zmazať všetky údaje tým, že sa obnovia továrenské nastavenia telefónu."</string>
    <string name="policylab_setGlobalProxy" msgid="2784828293747791446">"Nastaviť globálny server proxy zariadenia"</string>
    <string name="policydesc_setGlobalProxy" msgid="6387497466660154931">"Vyberte globálny server proxy, ktorý sa bude používať po aktivácii pravidiel. Platný globálny server proxy nastavuje iba prvý správca zariadenia."</string>
    <string name="policylab_expirePassword" msgid="885279151847254056">"Nastav. koniec platnosti hesla"</string>
    <string name="policydesc_expirePassword" msgid="1729725226314691591">"Nastavte, ako často sa musí zmeniť heslo na uzamknutie obrazovky."</string>
    <string name="policylab_encryptedStorage" msgid="8901326199909132915">"Nastaviť šifr. ukl. priestoru"</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="266329104542638802">"Zákaz funkcie v zámke kláves."</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="3467082272186534614">"Zabrániť používaniu niektorých funkcií v zámke klávesov."</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 do práce"</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 do práce"</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é číslo spoločnosti"</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">"TTY TDD"</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>
    <!-- no translation found for imProtocolGoogleTalk (493902321140277304) -->
    <skip />
    <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">"Domáci partner"</string>
    <string name="relationTypeFather" msgid="5228034687082050725">"Otec"</string>
    <string name="relationTypeFriend" msgid="7313106762483391262">"Priateľ"</string>
    <string name="relationTypeManager" msgid="6365677861610137895">"Manažér"</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">"Referencie od"</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="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="7858547464982981384"><font size="17">"Dotknutím zadajte heslo"</font></string>
    <string name="keyguard_password_enter_password_code" msgid="1054721668279049780">"Zadajte heslo na odomknutie"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="6391755146112503443">"Zadajte kód PIN na odomknutie"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="2422225591006134936">"Nesprávny kód PIN."</string>
    <string name="keyguard_label_text" msgid="861796461028298424">"Ak chcete telefón odomknúť, stlačte Menu a následne 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="696192103195090970">"Číslo tiesňového volania"</string>
    <string name="lockscreen_carrier_default" msgid="8963839242565653192">"Ž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="5347633784401285225">"Tiesňové volanie"</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="faceunlock_multiple_failures" msgid="754137583022792429">"Prekročili ste maximálny povolený počet pokusov o odomknutie tvárou"</string>
    <string name="lockscreen_plugged_in" msgid="8057762828355572315">"Prebieha nabíjanie, <xliff:g id="NUMBER">%d</xliff:g> <xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_charged" msgid="321635745684060624">"Nabitá batéria"</string>
    <string name="lockscreen_battery_short" msgid="4477264849386850266">"<xliff:g id="NUMBER">%d</xliff:g> <xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_low_battery" msgid="1482873981919249740">"Pripojte nabíjačku."</string>
    <string name="lockscreen_missing_sim_message_short" msgid="5099439277819215399">"Nie je vložená karta SIM"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="151659196095791474">"V tablete nie je žiadna karta SIM."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="2186920585695169078">"V telefóne nie je žiadna karta SIM."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="5372787138023272615">"Vložte kartu SIM."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3526573099019319472">"Karta SIM chýba alebo sa z nej nedá čítať. Vložte kartu SIM."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="5096149665138916184">"Karta SIM je nepoužiteľná."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="910904643433151371">"Vaša karta SIM bola natrvalo zakázaná."\n"Ak chcete získať inú kartu SIM, kontaktujte svojho operátora."</string>
    <string name="lockscreen_transport_prev_description" msgid="201594905152746886">"Tlačidlo Predchádzajúca stopa"</string>
    <string name="lockscreen_transport_next_description" msgid="6089297650481292363">"Tlačidlo Ďalšia stopa"</string>
    <string name="lockscreen_transport_pause_description" msgid="7659088786780128001">"Tlačidlo Pozastaviť"</string>
    <string name="lockscreen_transport_play_description" msgid="5888422938351019426">"Tlačidlo Prehrať"</string>
    <string name="lockscreen_transport_stop_description" msgid="4562318378766987601">"Tlačidlo Zastaviť"</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">"Karta SIM 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">"Karta SIM je uzamknutá."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="595323214052881264">"Prebieha odomykanie karty SIM..."</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6481623830344107222">"<xliff:g id="NUMBER_0">%d</xliff:g>-krát ste použili nesprávny bezpečnostný vzor. "\n\n"Skúste to znova o <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="2725973286239344555">"<xliff:g id="NUMBER_0">%d</xliff:g>-krát ste zadali nesprávne heslo. "\n\n"Skúste to znova o <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="6216672706545696955">"<xliff:g id="NUMBER_0">%d</xliff:g>-krát ste zadali nesprávny kód PIN. "\n\n"Skúste to znova o <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="9191611984625460820">"<xliff:g id="NUMBER_0">%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">%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">%d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="2590227559763762751">"<xliff:g id="NUMBER_0">%d</xliff:g>-krát ste nesprávne nakreslili svoj bezpečnostný vzor. Po <xliff:g id="NUMBER_1">%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">%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">%d</xliff:g>-krát. Po <xliff:g id="NUMBER_1">%d</xliff:g> ďalších neúspešných pokusoch sa v tablete obnovia predvolené továrenské nastavenia a všetky používateľské údaje budú stratené."</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">%d</xliff:g>-krát. Po <xliff:g id="NUMBER_1">%d</xliff:g> ďalších neúspešných pokusoch sa v telefóne obnovia predvolené továrenské 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é továrenské 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é továrenské 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?"\n"Navš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_detected" msgid="4988730895554057058">"Bezpečnostný vzor bol dokončený"</string>
    <string name="keyguard_accessibility_widget_changed" msgid="5678624624681400191">"%1$s. Miniaplikácia %2$d z %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8273277058724924654">"Pridať miniaplikáciu."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="1281505703307930757">"Prázdne"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="2278106022311170299">"Oblasť na odomknutie bola rozšírená."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="6366992066936076396">"Oblasť na odomknutie bola zúžená."</string>
    <string name="keyguard_accessibility_widget" msgid="6527131039741808240">"Miniaplikácia <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1226798370913698896">"Výber používateľa"</string>
    <string name="keyguard_accessibility_status" msgid="8008264603935930611">"Stav"</string>
    <string name="keyguard_accessibility_camera" msgid="8904231194181114603">"Fotoaparát"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="262209654292161806">"Ovládacie prvky médií"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="8736853615588828197">"Zmena usporiadania miniaplikácií sa začala."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="7170190950870468320">"Zmena usporiadania miniaplikácií sa skončila."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="4426204263929224434">"Miniaplikácia <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> bola odstránená."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="519859720934178024">"Rozšíriť oblasť na odomknutie."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2959928478764697254">"Odomknutie prejdením prstom."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="1490840706075246612">"Odomknutie vzorom."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="4817282543351718535">"Odomknutie tvárou."</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="2469687111784035046">"Odomknutie kódom PIN."</string>
    <string name="keyguard_accessibility_password_unlock" msgid="7675777623912155089">"Odomknutie heslom."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="7679891324509597904">"Oblasť na zadanie bezpečnostného vzoru."</string>
    <string name="keyguard_accessibility_slide_area" msgid="6736064494019979544">"Oblasť na prejdenie prstom."</string>
    <string name="password_keyboard_label_symbol_key" msgid="992280756256536042">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="8001096175167485649">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="1284820942620288678">"ALT"</string>
    <string name="granularity_label_character" msgid="7336470535385009523">"znak"</string>
    <string name="granularity_label_word" msgid="7075570328374918660">"slovo"</string>
    <string name="granularity_label_link" msgid="5815508880782488267">"odkaz"</string>
    <string name="granularity_label_line" msgid="5764267235026120888">"riadok"</string>
    <string name="hour_ampm" msgid="4584338083529355982">"<xliff:g id="HOUR">%-l</xliff:g> <xliff:g id="AMPM">%P</xliff:g>"</string>
    <string name="hour_cap_ampm" msgid="2083465992940444366">"<xliff:g id="HOUR">%-l</xliff:g> <xliff:g id="AMPM">%p</xliff:g>"</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\n"Naozaj chcete túto stránku opustiť?"</string>
    <string name="save_password_label" msgid="6860261758665825069">"Potvrdiť"</string>
    <string name="double_tap_toast" msgid="4595046515400268881">"Tip: Dvojitým klepnutím môžete zobrazenie priblížiť alebo oddialiť."</string>
    <string name="autofill_this_form" msgid="4616758841157816676">"Aut.dop."</string>
    <string name="setup_autofill" msgid="7103495070180590814">"Nast. Aut. dop."</string>
    <string name="autofill_address_name_separator" msgid="6350145154779706772">" "</string>
    <string name="autofill_address_summary_name_format" msgid="3268041054899214945">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="7483307893170324129">", "</string>
    <string name="autofill_address_summary_format" msgid="4874459455786827344">"$1$2$3"</string>
    <string name="autofill_province" msgid="2231806553863422300">"Provincia"</string>
    <string name="autofill_postal_code" msgid="4696430407689377108">"PSČ"</string>
    <string name="autofill_state" msgid="6988894195520044613">"Štát"</string>
    <string name="autofill_zip_code" msgid="8697544592627322946">"PSČ"</string>
    <string name="autofill_county" msgid="237073771020362891">"Kraj"</string>
    <string name="autofill_island" msgid="4020100875984667025">"Ostrov"</string>
    <string name="autofill_district" msgid="8400735073392267672">"Okres"</string>
    <string name="autofill_department" msgid="5343279462564453309">"Oddelenie"</string>
    <string name="autofill_prefecture" msgid="2028499485065800419">"Prefektúra"</string>
    <string name="autofill_parish" msgid="8202206105468820057">"Farnosť"</string>
    <string name="autofill_area" msgid="3547409050889952423">"Oblasť"</string>
    <string name="autofill_emirate" msgid="2893880978835698818">"Emirát"</string>
    <string name="permlab_readHistoryBookmarks" msgid="3775265775405106983">"čítať webové záložky a históriu"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="8462378226600439658">"Umožňuje aplikácii čítať všetky adresy URL 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="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="permlab_packageVerificationAgent" msgid="5568139100645829117">"overiť balíky"</string>
    <string name="permdesc_packageVerificationAgent" msgid="8437590190990843381">"Umožňuje aplikácii overiť, či je možné balík nainštalovať."</string>
    <string name="permlab_bindPackageVerifier" msgid="4187786793360326654">"naviazať na overovateľa balíka"</string>
    <string name="permdesc_bindPackageVerifier" msgid="3180741773233862126">"Umožňuje držiteľovi podávať žiadosti o overenie balíkov. Bežné aplikácie by toto nastavenie nemali nikdy potrebovať."</string>
    <string name="permlab_serialPort" msgid="546083327654631076">"prístup k sériovým portom"</string>
    <string name="permdesc_serialPort" msgid="2991639985224598193">"Držiteľa oprávňuje na prístup k sériovým portom pomocou rozhrania API SerialManager."</string>
    <string name="permlab_accessContentProvidersExternally" msgid="5077774297943409285">"externý prístup k poskytovateľom obsahu"</string>
    <string name="permdesc_accessContentProvidersExternally" msgid="4544346486697853685">"Povoľuje držiteľovi pristupovať k poskytovateľom obsahu z príkazového riadka. Normálne aplikácie by túto možnosť nikdy nemali potrebovať."</string>
    <string name="permlab_updateLock" msgid="3527558366616680889">"zakázať automatické aktualizácie zariad."</string>
    <string name="permdesc_updateLock" msgid="1655625832166778492">"Umožňuje držiteľovi poskytnúť systému informácie o vhodnom čase na automatický reštart zariadenia kvôli inovovaniu."</string>
    <string name="save_password_message" msgid="767344687139195790">"Chcete, aby si prehliadač zapamätal toto heslo?"</string>
    <string name="save_password_notnow" msgid="6389675316706699758">"Teraz nie"</string>
    <string name="save_password_remember" msgid="6491879678996749466">"Zapamätať"</string>
    <string name="save_password_never" msgid="8274330296785855105">"Nikdy"</string>
    <string name="open_permission_deny" msgid="7374036708316629800">"Nemáte povolenie na otvorenie tejto stránky."</string>
    <string name="text_copied" msgid="4985729524670131385">"Text bol skopírovaný do schránky."</string>
    <string name="more_item_label" msgid="4650918923083320495">"Viac"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Menu+"</string>
    <string name="menu_space_shortcut_label" msgid="2410328639272162537">"medzera"</string>
    <string name="menu_enter_shortcut_label" msgid="2743362785111309668">"potvrdiť"</string>
    <string name="menu_delete_shortcut_label" msgid="3658178007202748164">"odstrániť"</string>
    <string name="search_go" msgid="8298016669822141719">"Hľadať"</string>
    <string name="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">"Povoliť 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="num_seconds_ago">
    <item quantity="one" msgid="4869870056547896011">"pred 1 sekundou"</item>
    <item quantity="other" msgid="3903706804349556379">"pred <xliff:g id="COUNT">%d</xliff:g> s"</item>
  </plurals>
  <plurals name="num_minutes_ago">
    <item quantity="one" msgid="3306787433088810191">"Pred minútou"</item>
    <item quantity="other" msgid="2176942008915455116">"pred <xliff:g id="COUNT">%d</xliff:g> minútami"</item>
  </plurals>
  <plurals name="num_hours_ago">
    <item quantity="one" msgid="9150797944610821849">"pred 1 hodinou"</item>
    <item quantity="other" msgid="2467273239587587569">"pred <xliff:g id="COUNT">%d</xliff:g> hodinami"</item>
  </plurals>
  <plurals name="last_num_days">
    <item quantity="other" msgid="3069992808164318268">"Posledných <xliff:g id="COUNT">%d</xliff:g> dní"</item>
  </plurals>
    <string name="last_month" msgid="3959346739979055432">"Minulý mesiac"</string>
    <string name="older" msgid="5211975022815554840">"Staršie"</string>
  <plurals name="num_days_ago">
    <item quantity="one" msgid="861358534398115820">"včera"</item>
    <item quantity="other" msgid="2479586466153314633">"pred <xliff:g id="COUNT">%d</xliff:g> dňami"</item>
  </plurals>
  <plurals name="in_num_seconds">
    <item quantity="one" msgid="2729745560954905102">"o 1 sekundu"</item>
    <item quantity="other" msgid="1241926116443974687">"o <xliff:g id="COUNT">%d</xliff:g> s"</item>
  </plurals>
  <plurals name="in_num_minutes">
    <item quantity="one" msgid="8793095251325200395">"o 1 minútu"</item>
    <item quantity="other" msgid="3330713936399448749">"o <xliff:g id="COUNT">%d</xliff:g> minút"</item>
  </plurals>
  <plurals name="in_num_hours">
    <item quantity="one" msgid="7164353342477769999">"o 1 hodinu"</item>
    <item quantity="other" msgid="547290677353727389">"o <xliff:g id="COUNT">%d</xliff:g> hodín"</item>
  </plurals>
  <plurals name="in_num_days">
    <item quantity="one" msgid="5413088743009839518">"zajtra"</item>
    <item quantity="other" msgid="5109449375100953247">"o <xliff:g id="COUNT">%d</xliff:g> dní"</item>
  </plurals>
  <plurals name="abbrev_num_seconds_ago">
    <item quantity="one" msgid="1849036840200069118">"pred 1 s"</item>
    <item quantity="other" msgid="3699169366650930415">"pred <xliff:g id="COUNT">%d</xliff:g> s"</item>
  </plurals>
  <plurals name="abbrev_num_minutes_ago">
    <item quantity="one" msgid="6361490147113871545">"pred 1 min."</item>
    <item quantity="other" msgid="851164968597150710">"pred <xliff:g id="COUNT">%d</xliff:g> min."</item>
  </plurals>
  <plurals name="abbrev_num_hours_ago">
    <item quantity="one" msgid="4796212039724722116">"pred 1 hodinou"</item>
    <item quantity="other" msgid="6889970745748538901">"pred <xliff:g id="COUNT">%d</xliff:g> hodinami"</item>
  </plurals>
  <plurals name="abbrev_num_days_ago">
    <item quantity="one" msgid="8463161711492680309">"včera"</item>
    <item quantity="other" msgid="3453342639616481191">"pred <xliff:g id="COUNT">%d</xliff:g> dňami"</item>
  </plurals>
  <plurals name="abbrev_in_num_seconds">
    <item quantity="one" msgid="5842225370795066299">"o 1 s"</item>
    <item quantity="other" msgid="5495880108825805108">"o <xliff:g id="COUNT">%d</xliff:g> s"</item>
  </plurals>
  <plurals name="abbrev_in_num_minutes">
    <item quantity="one" msgid="562786149928284878">"o 1 min."</item>
    <item quantity="other" msgid="4216113292706568726">"o <xliff:g id="COUNT">%d</xliff:g> min."</item>
  </plurals>
  <plurals name="abbrev_in_num_hours">
    <item quantity="one" msgid="3274708118124045246">"o 1 hodinu"</item>
    <item quantity="other" msgid="3705373766798013406">"o <xliff:g id="COUNT">%d</xliff:g> hodín"</item>
  </plurals>
  <plurals name="abbrev_in_num_days">
    <item quantity="one" msgid="2178576254385739855">"zajtra"</item>
    <item quantity="other" msgid="2973062968038355991">"o <xliff:g id="COUNT">%d</xliff:g> dní"</item>
  </plurals>
    <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>
  <plurals name="duration_seconds">
    <item quantity="one" msgid="6962015528372969481">"1 s"</item>
    <item quantity="other" msgid="1886107766577166786">"<xliff:g id="COUNT">%d</xliff:g> s"</item>
  </plurals>
  <plurals name="duration_minutes">
    <item quantity="one" msgid="4915414002546085617">"1 min."</item>
    <item quantity="other" msgid="3165187169224908775">"<xliff:g id="COUNT">%d</xliff:g> min."</item>
  </plurals>
  <plurals name="duration_hours">
    <item quantity="one" msgid="8917467491248809972">"1 hod."</item>
    <item quantity="other" msgid="3863962854246773930">"<xliff:g id="COUNT">%d</xliff:g> hod."</item>
  </plurals>
    <string name="VideoView_error_title" msgid="3534509135438353077">"Problém s videom"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3186670335938670444">"Je nám ľúto, ale toto video sa nedá streamovať do tohto zariadenia."</string>
    <string name="VideoView_error_text_unknown" msgid="3450439155187810085">"Toto video nie je možné prehrať."</string>
    <string name="VideoView_error_button" msgid="2822238215100679592">"OK"</string>
    <string name="relative_time" msgid="1818557177829411417">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="7245353528818587908">"poludnie"</string>
    <string name="Noon" msgid="3342127745230013127">"Poludnie"</string>
    <string name="midnight" msgid="7166259508850457595">"polnoc"</string>
    <string name="Midnight" msgid="5630806906897892201">"Polnoc"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="4431555943828711473">"<xliff:g id="MINUTES">%1$02d</xliff:g>:<xliff:g id="SECONDS">%2$02d</xliff:g>"</string>
    <string name="elapsed_time_short_format_h_mm_ss" msgid="1846071997616654124">"<xliff:g id="HOURS">%1$d</xliff:g>:<xliff:g id="MINUTES">%2$02d</xliff:g>:<xliff:g id="SECONDS">%3$02d</xliff:g>"</string>
    <string name="selectAll" msgid="6876518925844129331">"Vybrať všetko"</string>
    <string name="cut" msgid="3092569408438626261">"Vystrihnúť"</string>
    <string name="copy" msgid="2681946229533511987">"Kopírovať"</string>
    <string name="paste" msgid="5629880836805036433">"Prilepiť"</string>
    <string name="replace" msgid="5781686059063148930">"Nahradiť•"</string>
    <string name="delete" msgid="6098684844021697789">"Odstrániť"</string>
    <string name="copyUrl" msgid="2538211579596067402">"Skopírovať adresu URL"</string>
    <string name="selectTextMode" msgid="1018691815143165326">"Vybrať text"</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="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="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="4653586947747330058">"Dotykom si zobrazíte viac informácií 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">"Pozor"</string>
    <string name="loading" msgid="7933681260296021180">"Prebieha načítavanie..."</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="alwaysUse" msgid="4583018368000610438">"Použiť ako predvolené nastavenie pre túto akciu."</string>
    <string name="clearDefaultHintMsg" msgid="3252584689512077257">"Vymazať predvolené nastavenia v sekcii Nastavenia systému &gt; Aplikácie &gt; Prevzaté 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_title" msgid="1905800560317137752"></string>
    <string name="aerr_application" msgid="932628488013092776">"Aplikácia <xliff:g id="APPLICATION">%1$s</xliff:g> bohužiaľ prestala pracovať."</string>
    <string name="aerr_process" msgid="4507058997035697579">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> bohužiaľ prestal pracovať."</string>
    <string name="anr_title" msgid="4351948481459135709"></string>
    <string name="anr_activity_application" msgid="1904477189057199066">"Aplikácia <xliff:g id="APPLICATION">%2$s</xliff:g> neodpovedá."\n\n"Chcete ju zavrieť?"</string>
    <string name="anr_activity_process" msgid="5776209883299089767">"Aktivita <xliff:g id="ACTIVITY">%1$s</xliff:g> neodpovedá."\n\n"Chcete ju zavrieť?"</string>
    <string name="anr_application_process" msgid="8941757607340481057">"Aplikácia <xliff:g id="APPLICATION">%1$s</xliff:g> neodpovedá. Chcete ju zavrieť?"</string>
    <string name="anr_process" msgid="6513209874880517125">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> neodpovedá. "\n\n"Chcete ho zavrieť?"</string>
    <string name="force_close" msgid="8346072094521265605">"OK"</string>
    <string name="report" msgid="4060218260984795706">"Prehľad"</string>
    <string name="wait" msgid="7147118217226317732">"Čakajte"</string>
    <string name="webpage_unresponsive" msgid="3272758351138122503">"Stránka nereaguje."\n\n"Chcete 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; Prevzaté súbory."</string>
    <string name="smv_application" msgid="3307209192155442829">"Aplikácia <xliff:g id="APPLICATION">%1$s</xliff:g> (proces <xliff:g id="PROCESS">%2$s</xliff:g>) porušila svoje vlastné vynútené pravidlá StrictMode."</string>
    <string name="smv_process" msgid="5120397012047462446">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> porušil svoje vlastné vynútené pravidlá StrictMode."</string>
    <string name="android_upgrading_title" msgid="1584192285441405746">"Prebieha inovácia systému Android..."</string>
    <string name="android_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_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="1721681741617898865">"Dotknutím prepnite na aplikáciu"</string>
    <string name="heavy_weight_switcher_title" msgid="7153167085403298169">"Prepnúť aplikácie?"</string>
    <string name="heavy_weight_switcher_text" msgid="7022631924534406403">"Pred spustením novej aplikácie treba zastaviť inú spustenú aplikáciu."</string>
    <string name="old_app_action" msgid="493129172238566282">"Návrat k <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="old_app_description" msgid="2082094275580358049">"Nespúšťať novú aplikáciu."</string>
    <string name="new_app_action" msgid="5472756926945440706">"Spustiť <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="1932143598371537340">"Zastaviť starú aplikáciu bez uloženia."</string>
    <string name="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íka"</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="8129563480895990372">"Predvolený tón zvonenia (<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">"Vyzváňacie tóny"</string>
    <string name="ringtone_unknown" msgid="5477919988701784788">"Neznámy tón zvonenia"</string>
  <plurals name="wifi_available">
    <item quantity="one" msgid="6654123987418168693">"K dispozícii je sieť Wi-Fi"</item>
    <item quantity="other" msgid="4192424489168397386">"K dispozícii sú siete Wi-Fi."</item>
  </plurals>
  <plurals name="wifi_available_detailed">
    <item quantity="one" msgid="1634101450343277345">"K dispozícii je verejná sieť Wi-Fi"</item>
    <item quantity="other" msgid="7915895323644292768">"K dispozícii sú verejné siete Wi-Fi"</item>
  </plurals>
    <string name="wifi_available_sign_in" msgid="4029489716605255386">"Prihlásenie sa do siete Wi-Fi"</string>
    <string name="network_available_sign_in" msgid="8495155593358054676">"Prihláste sa do siete"</string>
    <!-- no translation found for network_available_sign_in_detailed (8000081941447976118) -->
    <skip />
    <string name="wifi_watchdog_network_disabled" msgid="7904214231651546347">"Nepodarilo sa pripojiť k sieti Wi-Fi"</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="5548780776418332675">" má nekvalitné internetové pripojenie."</string>
    <string name="wifi_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="1638949953993894335">"Nastavenia otvoríte dotykom"</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="default" msgid="7363907213787469151">"Telefón bude počas pripojenia k zariadeniu <xliff:g id="DEVICE_NAME">%1$s</xliff:g> od siete Wi-Fi dočasne odpojený."</string>
    <string name="select_character" msgid="3365550120617701745">"Vkladanie znakov"</string>
    <string name="sms_control_title" msgid="7296612781128917719">"Odosielanie správ SMS"</string>
    <string name="sms_control_message" msgid="3867899169651496433">"Aplikácia &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; posiela veľký počet správ SMS. Chcete tejto aplikácií povoliť, aby aj naďalej posielala správy?"</string>
    <string name="sms_control_yes" msgid="3663725993855816807">"Povoliť"</string>
    <string name="sms_control_no" msgid="625438561395534982">"Odmietnuť"</string>
    <string name="sms_short_code_confirm_message" msgid="1645436466285310855">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; chce odoslať správu na adresu &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="3492025719868078457"><font fgcolor="#ffffb060">"Môžu sa účtovať poplatky"</font>" na váš mobilný účet."</string>
    <string name="sms_premium_short_code_details" msgid="5523826349105123687"><font fgcolor="#ffffb060">"Budú sa účtovať poplatky na váš mobilný účet."</font></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">"Karta SIM bola odobraná"</string>
    <string name="sim_removed_message" msgid="2333164559970958645">"Mobilná sieť nebude k dispozícii, kým nevložíte platnú kartu SIM a zariadenie nereštartujete."</string>
    <string name="sim_done_button" msgid="827949989369963775">"Hotovo"</string>
    <string name="sim_added_title" msgid="3719670512889674693">"Bola pridaná karta SIM"</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="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="usb_storage_activity_title" msgid="4465055157209648641">"Veľkokapacitné úložisko USB"</string>
    <string name="usb_storage_title" msgid="5901459041398751495">"Zariadenie USB pripojené"</string>
    <string name="usb_storage_message" product="nosdcard" msgid="3308538094316477839">"Zariadenie ste pripojili k počítaču pomocou portu USB. Ak chcete kopírovať súbory z počítača do ukladacieho priestoru USB v zariadení so systémom Android alebo naopak, dotknite sa tlačidla nižšie."</string>
    <string name="usb_storage_message" product="default" msgid="805351000446037811">"Zariadenie ste pripojili k počítaču pomocou USB. Ak chcete kopírovať súbory z počítača na kartu SD v zariadení so systémom Android alebo naopak, dotknite sa tlačidla nižšie."</string>
    <string name="usb_storage_button_mount" msgid="1052259930369508235">"Zapnúť ukladací priestor USB"</string>
    <string name="usb_storage_error_message" product="nosdcard" msgid="3017045217365540658">"Pri používaní vášho úložiska USB ako veľkokapacitného ukladacieho priestoru USB sa vyskytol problém."</string>
    <string name="usb_storage_error_message" product="default" msgid="2876018512716970313">"Pri používaní vašej karty SD ako veľkokapacitného ukladacieho priestoru USB sa vyskytol problém."</string>
    <string name="usb_storage_notification_title" msgid="8175892554757216525">"Zariadenie USB pripojené"</string>
    <string name="usb_storage_notification_message" msgid="939822783828183763">"Dotykom skopírujete súbory do / z počítača."</string>
    <string name="usb_storage_stop_notification_title" msgid="2336058396663516017">"Vypnúť ukladací priestor USB"</string>
    <string name="usb_storage_stop_notification_message" msgid="1656852098555623822">"Dotykom vypnete ukladací priestor USB."</string>
    <string name="usb_storage_stop_title" msgid="660129851708775853">"Ukladací priestor USB sa používa"</string>
    <string name="usb_storage_stop_message" product="nosdcard" msgid="4264025280777219521">"Pred vypnutím ukladacieho priestoru USB odpojte od počítača („vysuňte“) ukladací priestor USB systému Android."</string>
    <string name="usb_storage_stop_message" product="default" msgid="8043969782460613114">"Pred vypnutím ukladacieho priestoru USB odpojte („vysuňte“) z počítača kartu SD zariadenia Android."</string>
    <string name="usb_storage_stop_button_mount" msgid="7060218034900696029">"Vypnúť ukladací priestor USB"</string>
    <string name="usb_storage_stop_error_message" msgid="1970374898263063836">"Pri vypínaní ukladacieho priestoru USB sa vyskytol problém. Uistite sa, či bol hostiteľ USB odpojený, a skúste to znova."</string>
    <string name="dlg_confirm_kill_storage_users_title" msgid="963039033470478697">"Zapnúť ukladací priestor USB"</string>
    <string name="dlg_confirm_kill_storage_users_text" msgid="5100428757107469454">"Ak zapnete úložisko USB, dôjde k zastaveniu niektorých používaných aplikácií. Tieto aplikácie pravdepodobne nebudú k dispozícii až do vypnutia úložiska USB."</string>
    <string name="dlg_error_title" msgid="7323658469626514207">"Operácia rozhrania USB bola neúspešná"</string>
    <string name="dlg_ok" msgid="7376953167039865701">"OK"</string>
    <string name="usb_mtp_notification_title" msgid="3699913097391550394">"Pripojené ako mediálne zariadenie"</string>
    <string name="usb_ptp_notification_title" msgid="1960817192216064833">"Pripojené ako fotoaparát"</string>
    <string name="usb_cd_installer_notification_title" msgid="6774712827892090754">"Pripojené ako inštalátor"</string>
    <string name="usb_accessory_notification_title" msgid="7848236974087653666">"Pripojené k periférnemu zariadeniu USB"</string>
    <string name="usb_notification_message" msgid="2290859399983720271">"Dotykom zobrazíte ďalšie možnosti USB."</string>
    <string name="extmedia_format_title" product="nosdcard" msgid="9020092196061007262">"Formátovať ukladací priestor USB?"</string>
    <string name="extmedia_format_title" product="default" msgid="3648415921526526069">"Formátovať kartu SD?"</string>
    <string name="extmedia_format_message" product="nosdcard" msgid="3934016853425761078">"Všetky súbory uložené v ukladacom priestore USB budú vymazané. Táto akcia sa nedá vrátiť späť!"</string>
    <string name="extmedia_format_message" product="default" msgid="14131895027543830">"Všetky údaje na vašej karte budú stratené."</string>
    <string name="extmedia_format_button_format" msgid="4131064560127478695">"Formát"</string>
    <string name="adb_active_notification_title" msgid="6729044778949189918">"Ladenie cez rozhranie USB pripojené"</string>
    <string name="adb_active_notification_message" msgid="1016654627626476142">"Dotknutím zakážete ladenie USB."</string>
    <string name="select_input_method" msgid="4653387336791222978">"Zvoliť metódu vstupu"</string>
    <string name="configure_input_methods" msgid="9091652157722495116">"Nastavenie metód vstupu"</string>
    <string name="use_physical_keyboard" msgid="6203112478095117625">"Fyzická klávesnica"</string>
    <string name="hardware" msgid="7517821086888990278">"Hardvér"</string>
    <string name="select_keyboard_layout_notification_title" msgid="1407367017263030773">"Zvoľte rozloženie klávesnice"</string>
    <string name="select_keyboard_layout_notification_message" msgid="4465907700449257063">"Dotykom zvoľte rozloženie klávesnice."</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="candidates_style" msgid="4333913089637062257"><u>"kandidáti"</u></string>
    <string name="ext_media_checking_notification_title" product="nosdcard" msgid="3449816005351468560">"Príprava uklad. priestoru USB"</string>
    <string name="ext_media_checking_notification_title" product="default" msgid="5457603418970994050">"Príprava karty SD"</string>
    <string name="ext_media_checking_notification_message" msgid="8287319882926737053">"Kontrola chýb."</string>
    <string name="ext_media_nofs_notification_title" product="nosdcard" msgid="7788040745686229307">"Prázdny ukladací priestor USB"</string>
    <string name="ext_media_nofs_notification_title" product="default" msgid="780477838241212997">"Prázdna karta SD"</string>
    <string name="ext_media_nofs_notification_message" product="nosdcard" msgid="7840121067427269500">"Ukladací priestor USB je prázdny alebo obsahuje nepodporovaný systém súborov."</string>
    <string name="ext_media_nofs_notification_message" product="default" msgid="8641065641786923604">"Karta SD je prázdna alebo obsahuje nepodporovaný systém súborov."</string>
    <string name="ext_media_unmountable_notification_title" product="nosdcard" msgid="2090046769532713563">"Ukl. priestor USB je poškodený"</string>
    <string name="ext_media_unmountable_notification_title" product="default" msgid="6410723906019100189">"Poškodená karta SD"</string>
    <string name="ext_media_unmountable_notification_message" product="nosdcard" msgid="1795917578395333280">"Ukladací priestor USB je poškodený. Skúste ho preformátovať."</string>
    <string name="ext_media_unmountable_notification_message" product="default" msgid="1753898567525568253">"Karta SD je poškodená. Skúste ju preformátovať."</string>
    <string name="ext_media_badremoval_notification_title" product="nosdcard" msgid="1661683031330951073">"Ukl. priestor USB nečakane odstránený"</string>
    <string name="ext_media_badremoval_notification_title" product="default" msgid="6872152882604407837">"Karta SD bola neočakávane odobraná"</string>
    <string name="ext_media_badremoval_notification_message" product="nosdcard" msgid="4329848819865594241">"Ak chcete zabrániť strate údajov, ukladací priestor USB pred odobratím odpojte."</string>
    <string name="ext_media_badremoval_notification_message" product="default" msgid="7260183293747448241">"Ak chcete zabrániť strate údajov, kartu SD pred odobratím odpojte."</string>
    <string name="ext_media_safe_unmount_notification_title" product="nosdcard" msgid="3967973893270360230">"Ukl. priestor USB môžete odobrať"</string>
    <string name="ext_media_safe_unmount_notification_title" product="default" msgid="6729801130790616200">"Kartu SD je možné bezpečne odobrať"</string>
    <string name="ext_media_safe_unmount_notification_message" product="nosdcard" msgid="6142195361606493530">"Ukladací priestor USB môžete bezpečne odstrániť."</string>
    <string name="ext_media_safe_unmount_notification_message" product="default" msgid="568841278138377604">"Kartu SD je možné bezpečne odobrať."</string>
    <string name="ext_media_nomedia_notification_title" product="nosdcard" msgid="4486377230140227651">"Ukl. priestor USB odstránený"</string>
    <string name="ext_media_nomedia_notification_title" product="default" msgid="8902518030404381318">"Karta SD bola odobraná"</string>
    <string name="ext_media_nomedia_notification_message" product="nosdcard" msgid="6921126162580574143">"Ukladací priestor USB odstránený. Vložte nové médium."</string>
    <string name="ext_media_nomedia_notification_message" product="default" msgid="3870120652983659641">"Karta SD bola odobraná. Vložte novú kartu."</string>
    <string name="activity_list_empty" msgid="1675388330786841066">"Nenašli sa žiadne zodpovedajúce aktivity."</string>
    <string name="permlab_pkgUsageStats" msgid="8787352074326748892">"aktualizovať štatistiku použitia súčastí"</string>
    <string name="permdesc_pkgUsageStats" msgid="1106612424254277630">"Umožňuje aplikácii zmeniť zhromaždené štatistické údaje o súčasti. Bežné aplikácie toto nastavenie nepoužívajú."</string>
    <string name="permlab_copyProtectedData" msgid="4341036311211406692">"kopírovať obsah"</string>
    <string name="permdesc_copyProtectedData" msgid="4390697124288317831">"Umožňuje volať predvolenú službu kontajnera na skopírovanie obsahu. Bežné aplikácie toto nastavenie nepoužívajú."</string>
    <string name="permlab_route_media_output" msgid="1642024455750414694">"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="tutorial_double_tap_to_zoom_message_short" msgid="4070433208160063538">"Ovládacie prvky lupy zobrazíte dvojitým dotknutím"</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"\n"pre <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"\n"pre účet <xliff:g id="ACCOUNT">%s</xliff:g>"</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">"Zjednodušenie"</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="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="3011306607126450322">"Dotykom môžete spravovať sieť."</string>
    <string name="vpn_text_long" msgid="6407351006249174473">"Pripojené k relácii <xliff:g id="SESSION">%s</xliff:g>. Po dotyku môžete sieť spravovať."</string>
    <string name="vpn_lockdown_connecting" msgid="6443438964440960745">"Prebieha 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_error" msgid="6009249814034708175">"Chyba vždy zapnutej siete VPN"</string>
    <string name="vpn_lockdown_config" msgid="6415899150671537970">"Dotykom spustíte konfiguráciu"</string>
    <string name="upload_file" msgid="2897957172366730416">"Zvoliť súbor"</string>
    <string name="no_file_chosen" msgid="6363648562170759465">"Nie je vybratý žiadny súbor"</string>
    <string name="reset" msgid="2448168080964209908">"Obnoviť"</string>
    <string name="submit" msgid="1602335572089911941">"Odoslať"</string>
    <string name="car_mode_disable_notification_title" msgid="3164768212003864316">"Aktivovaný režim V aute"</string>
    <string name="car_mode_disable_notification_message" msgid="8035230537563503262">"Dotykom ukončite režim V aute."</string>
    <string name="tethered_notification_title" msgid="3146694234398202601">"Tethering alebo prístupový bod je aktívny"</string>
    <string name="tethered_notification_message" msgid="6857031760103062982">"Dotykom nastavte."</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="throttle_warning_notification_title" msgid="4890894267454867276">"Vysoké využitie mobilných údajov"</string>
    <string name="throttle_warning_notification_message" msgid="3340822228599337743">"Dotykom zobrazíte viac informácií o využití mobilných údajov."</string>
    <string name="throttled_notification_title" msgid="6269541897729781332">"Bol prekročený limit mobilných údajov"</string>
    <string name="throttled_notification_message" msgid="5443457321354907181">"Dotykom zobrazíte viac informácií o využití mobilných údajov."</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">
    <item quantity="one" msgid="8167147081136579439">"Počet zhôd: 1"</item>
    <item quantity="other" msgid="4641872797067609177">"<xliff:g id="INDEX">%d</xliff:g> z <xliff:g id="TOTAL">%d</xliff:g>"</item>
  </plurals>
    <string name="action_mode_done" msgid="7217581640461922289">"Hotovo"</string>
    <string name="progress_unmounting" product="nosdcard" msgid="3923810448507612746">"Prebieha odpájanie úložiska USB..."</string>
    <string name="progress_unmounting" product="default" msgid="1327894998409537190">"Prebieha odpájanie karty SD..."</string>
    <string name="progress_erasing" product="nosdcard" msgid="4521573321524340058">"Prebieha vymazávanie ukladacieho priestoru USB..."</string>
    <string name="progress_erasing" product="default" msgid="6596988875507043042">"Prebieha vymazávanie karty SD..."</string>
    <string name="format_error" product="nosdcard" msgid="6299769563624776948">"Nepodarilo sa vymazať ukladací priestor USB"</string>
    <string name="format_error" product="default" msgid="7315248696644510935">"Nepodarilo sa vymazať kartu SD"</string>
    <string name="media_bad_removal" msgid="7960864061016603281">"Karta SD nebola pred odstránením odpojená."</string>
    <string name="media_checking" product="nosdcard" msgid="418188720009569693">"Prebieha kontrola ukladacieho priestoru USB."</string>
    <string name="media_checking" product="default" msgid="7334762503904827481">"Prebieha kontrola karty SD."</string>
    <string name="media_removed" msgid="7001526905057952097">"Karta SD bola odstránená."</string>
    <string name="media_shared" product="nosdcard" msgid="5830814349250834225">"Ukladací priestor USB je momentálne používaný počítačom."</string>
    <string name="media_shared" product="default" msgid="5706130568133540435">"Karta SD sa momentálne používa počítačom."</string>
    <string name="media_unknown_state" msgid="729192782197290385">"Neznámy stav externého média."</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="3073101067441638428">"Dotknite sa a podržte <xliff:g id="VALUE">%s</xliff:g>."</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 dopoludnia"</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="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="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_direction_up" msgid="7169032478259485180">"Prejdite prstom nahor: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_down" msgid="5087739728639014595">"Prejdite prstom nadol: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_left" msgid="7207478719805562165">"Prejdite prstom doľava: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_direction_right" msgid="8034433242579600980">"Prejdite prstom doprava: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
    <string name="description_target_unlock" msgid="2228524900439801453">"Odomknúť"</string>
    <string name="description_target_camera" msgid="969071997552486814">"Fotoaparát"</string>
    <string name="description_target_silent" msgid="893551287746522182">"Tichý"</string>
    <string name="description_target_soundon" msgid="30052466675500172">"Zapnúť zvuk"</string>
    <string name="description_target_search" msgid="3091587249776033139">"Vyhľadávanie"</string>
    <string name="description_target_unlock_tablet" msgid="3833195335629795055">"Posunom odomknúť."</string>
    <string name="keyboard_headset_required_to_hear_password" msgid="7011927352267668657">"Ak si chcete vypočuť vyslovené klávesy hesla, pripojte náhlavnú súpravu."</string>
    <string name="keyboard_password_character_no_headset" msgid="2859873770886153678">"Bodka."</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="4891916833657929263">"Interné úložisko"</string>
    <string name="storage_sd_card" msgid="3282948861378286745">"Karta SD"</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="1955638862122232342">"Upozornenie o využití dát"</string>
    <string name="data_usage_warning_body" msgid="2814673551471969954">"Zobr. využív. dát a nastavení."</string>
    <string name="data_usage_3g_limit_title" msgid="7093334419518706686">"Dátové prenosy 2G a 3G zakázané"</string>
    <string name="data_usage_4g_limit_title" msgid="7636489436819470761">"Dátové prenosy 4G zakázané"</string>
    <string name="data_usage_mobile_limit_title" msgid="7869402519391631884">"Mobilné dátové prenosy zakázané"</string>
    <string name="data_usage_wifi_limit_title" msgid="8992154736441284865">"Prenos dát cez Wi-Fi – zakázaný"</string>
    <string name="data_usage_limit_body" msgid="3317964706973601386">"Dotykom povoľte."</string>
    <string name="data_usage_3g_limit_snoozed_title" msgid="7026739121138005231">"2G, 3G dátový limit prekročený"</string>
    <string name="data_usage_4g_limit_snoozed_title" msgid="1106562779311209039">"Dátový limit 4G bol prekročený"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="279240572165412168">"Prekroč. limit pre mobil. dáta"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="8743856006384825974">"Dát. limit Wi-Fi bol prekročený"</string>
    <string name="data_usage_limit_snoozed_body" msgid="7035490278298441767">"<xliff:g id="SIZE">%s</xliff:g> nad stanovenou hranicou."</string>
    <string name="data_usage_restricted_title" msgid="5965157361036321914">"Údaje na pozadí sú obmedzené"</string>
    <string name="data_usage_restricted_body" msgid="6741521330997452990">"Dotykom odstránite obmedzenie."</string>
    <string name="ssl_certificate" msgid="6510040486049237639">"Certifikát zabezpečenia"</string>
    <string name="ssl_certificate_is_valid" msgid="6825263250774569373">"Certifikát je platný."</string>
    <string name="issued_to" msgid="454239480274921032">"Vydané pre:"</string>
    <string name="common_name" msgid="2233209299434172646">"Bežný názov:"</string>
    <string name="org_name" msgid="6973561190762085236">"Organizácia:"</string>
    <string name="org_unit" msgid="7265981890422070383">"Organizačná jednotka:"</string>
    <string name="issued_by" msgid="2647584988057481566">"Vydal:"</string>
    <string name="validity_period" msgid="8818886137545983110">"Platnosť:"</string>
    <string name="issued_on" msgid="5895017404361397232">"Dátum vydania:"</string>
    <string name="expires_on" msgid="3676242949915959821">"Platnosť vyprší:"</string>
    <string name="serial_number" msgid="758814067660862493">"Sériové číslo:"</string>
    <string name="fingerprints" msgid="4516019619850763049">"Digitálne odtlačky:"</string>
    <string name="sha256_fingerprint" msgid="4391271286477279263">"Digitálny odtlačok SHA-256:"</string>
    <string name="sha1_fingerprint" msgid="7930330235269404581">"Digitálny odtlačok SHA-1:"</string>
    <string name="activity_chooser_view_see_all" msgid="4292569383976636200">"Zobraziť všetky"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="4710013864974040615">"Vybrať aktivitu"</string>
    <string name="share_action_provider_share_with" msgid="5247684435979149216">"Zdieľať s"</string>
    <string name="status_bar_device_locked" msgid="3092703448690669768">"Zariadenie je zamknuté."</string>
    <string name="list_delimeter" msgid="3975117572185494152">", "</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="default_audio_route_name" product="tablet" msgid="4617053898167127471">"Tablet"</string>
    <string name="default_audio_route_name" product="default" msgid="4239291273420140123">"Telefón"</string>
    <string name="default_audio_route_name_headphones" msgid="8119971843803439110">"Slúchadlá"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="6240602982276591864">"Reproduktory doku"</string>
    <string name="default_media_route_name_hdmi" msgid="2450970399023478055">"HDMI"</string>
    <string name="default_audio_route_category_name" msgid="3722811174003886946">"Systém"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="8575624030406771015">"Bluetooth audio"</string>
    <string name="wireless_display_route_description" msgid="9070346425023979651">"Bezdrôtový displej"</string>
    <string name="media_route_chooser_grouping_done" msgid="7966438307723317169">"Hotovo"</string>
    <string name="media_route_button_content_description" msgid="5758553567065145276">"Výstup médií"</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="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="wifi_display_notification_title" msgid="2223050649240326557">"Bezdrôtový displej je pripojený"</string>
    <string name="wifi_display_notification_message" msgid="4498802012464170685">"Táto obrazovka sa zobrazuje na inom zariadení"</string>
    <string name="wifi_display_notification_disconnect" msgid="6183754463561153372">"Odpojiť"</string>
    <string name="kg_emergency_call_label" msgid="684946192523830531">"Tiesňové volanie"</string>
    <string name="kg_forgot_pattern_button_text" msgid="8852021467868220608">"Nepamätám si vzor"</string>
    <string name="kg_wrong_pattern" msgid="1850806070801358830">"Nesprávny vzor"</string>
    <string name="kg_wrong_password" msgid="2333281762128113157">"Nesprávne heslo"</string>
    <string name="kg_wrong_pin" msgid="1131306510833563801">"Nesprávny kód PIN"</string>
    <string name="kg_too_many_failed_attempts_countdown" msgid="6358110221603297548">"Skúste to znova o <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="kg_pattern_instructions" msgid="398978611683075868">"Nakreslite svoj vzor"</string>
    <string name="kg_sim_pin_instructions" msgid="2319508550934557331">"Zadajte kód PIN karty SIM"</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">"Karta SIM 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 karty SIM..."</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="7553388325654369575">"Kód PUK musí obsahovať 8 alebo viac číslic."</string>
    <string name="kg_invalid_puk" msgid="3638289409676051243">"Znova zadajte správny kód PUK. Opakované pokusy zakážu kartu SIM 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">%d</xliff:g>-krát ste zadali nesprávny kód PIN. "\n\n"Skúste to znova o <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="7813713389422226531">"<xliff:g id="NUMBER_0">%d</xliff:g>-krát ste zadali nesprávne heslo. "\n\n"Skúste to znova o <xliff:g id="NUMBER_1">%d</xliff:g>."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="74089475965050805">"<xliff:g id="NUMBER_0">%d</xliff:g>-krát ste použili nesprávny bezpečnostný vzor. "\n\n"Skúste to znova o <xliff:g id="NUMBER_1">%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">%d</xliff:g>-krát. Po <xliff:g id="NUMBER_1">%d</xliff:g> ďalších neúspešných pokusoch sa v tablete obnovia predvolené továrenské nastavenia a všetky používateľské údaje budú stratené."</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">%d</xliff:g>-krát. Po <xliff:g id="NUMBER_1">%d</xliff:g> ďalších neúspešných pokusoch sa v telefóne obnovia predvolené továrenské 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é továrenské 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é továrenské nastavenia."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="3253575572118914370">"<xliff:g id="NUMBER_0">%d</xliff:g>-krát ste nesprávne nakreslili svoj bezpečnostný vzor. Po ďalších <xliff:g id="NUMBER_1">%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">%d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="1437638152015574839">"<xliff:g id="NUMBER_0">%d</xliff:g>-krát ste nesprávne nakreslili svoj bezpečnostný vzor. Po <xliff:g id="NUMBER_1">%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">%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="7324161939475478066">"Zvýšiť hlasitosť nad odporúčanú úroveň?"\n"Dlhodobé počúvanie pri vysokej hlasitosti môže poškodiť váš sluch."</string>
    <string name="continue_to_enable_accessibility" msgid="1626427372316070258">"Zjednodušenie ovládania povolíte dlhým stlačením dvoma prstami."</string>
    <string name="accessibility_enabled" msgid="1381972048564547685">"Zjednodušenie ovládania je povolené."</string>
    <string name="enable_accessibility_canceled" msgid="3833923257966635673">"Zjednodušenie ovládania bolo zrušené."</string>
    <string name="user_switched" msgid="3768006783166984410">"Aktuálny používateľ je <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="app_no_restricted_accounts" msgid="4011285085817350390">"Táto aplikácia nepodporuje účty pre profily s obmedzením"</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>
</resources>
