<?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="202579285008794431">"B"</string>
    <string name="kilobyteShort" msgid="2214285521564195803">"KB"</string>
    <string name="megabyteShort" msgid="6649361267635823443">"MB"</string>
    <string name="gigabyteShort" msgid="7515809460261287991">"GB"</string>
    <string name="terabyteShort" msgid="1822367128583886496">"TB"</string>
    <string name="petabyteShort" msgid="5651571254228534832">"PB"</string>
    <string name="fileSizeSuffix" msgid="4233671691980131257">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="untitled" msgid="3381766946944136678">"&lt;Brez naslova&gt;"</string>
    <string name="emptyPhoneNumber" msgid="5812172618020360048">"(Ni telefonske številke)"</string>
    <string name="unknownName" msgid="7078697621109055330">"Neznano"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2190754495304236490">"Glasovna pošta"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2285034592902077488">"MSISDN1"</string>
    <string name="mmiError" msgid="2862759606579822246">"Težava s povezavo ali neveljavna koda MMI."</string>
    <string name="mmiFdnError" msgid="3975490266767565852">"Operacija je omejena na dovoljene telefonske številke, za katere ne velja zapora odhodnega klica."</string>
    <string name="mmiErrorWhileRoaming" msgid="1204173664713870114">"Nastavitev preusmerjanja klicev ni mogoče spremeniti v telefonu med gostovanjem v tujem omrežju."</string>
    <string name="serviceEnabled" msgid="7549025003394765639">"Storitev je omogočena."</string>
    <string name="serviceEnabledFor" msgid="1463104778656711613">"Storitev je bila omogočena za:"</string>
    <string name="serviceDisabled" msgid="641878791205871379">"Storitev je onemogočena."</string>
    <string name="serviceRegistered" msgid="3856192211729577482">"Registracija je bila uspešna."</string>
    <string name="serviceErased" msgid="997354043770513494">"Izbris je bil uspešen."</string>
    <string name="passwordIncorrect" msgid="917087532676155877">"Nepravilno geslo."</string>
    <string name="mmiComplete" msgid="6341884570892520140">"MMI dokončan."</string>
    <string name="badPin" msgid="888372071306274355">"Vneseni stari PIN ni pravilen."</string>
    <string name="badPuk" msgid="4232069163733147376">"Vneseni PUK ni pravilen."</string>
    <string name="mismatchPin" msgid="2929611853228707473">"Vneseni številki PIN se ne ujemata."</string>
    <string name="invalidPin" msgid="7542498253319440408">"Vnesite PIN, ki vsebuje od štiri do osem številk."</string>
    <string name="invalidPuk" msgid="8831151490931907083">"Vnesite 8- ali več mestni PUK."</string>
    <string name="needPuk" msgid="7321876090152422918">"Kartica SIM je zaklenjena s kodo PUK. Če jo želite odkleniti, vnesite kodo PUK."</string>
    <string name="needPuk2" msgid="7032612093451537186">"Če želite odstraniti blokiranje kartice SIM, vnesite PUK2."</string>
    <string name="enablePin" msgid="2543771964137091212">"Ni uspelo. Omogočite zaklepanje kartice SIM/RUIM."</string>
    <plurals name="pinpuk_attempts" formatted="false" msgid="1619867269012213584">
      <item quantity="one">Na voljo imate še <xliff:g id="NUMBER_1">%d</xliff:g> poskus. Potem se bo kartica SIM zaklenila.</item>
      <item quantity="two">Na voljo imate še <xliff:g id="NUMBER_1">%d</xliff:g> poskusa. Potem se bo kartica SIM zaklenila.</item>
      <item quantity="few">Na voljo imate še <xliff:g id="NUMBER_1">%d</xliff:g> poskuse. Potem se bo kartica SIM zaklenila.</item>
      <item quantity="other">Na voljo imate še <xliff:g id="NUMBER_1">%d</xliff:g> poskusov. Potem se bo kartica SIM zaklenila.</item>
    </plurals>
    <string name="imei" msgid="2157082351232630390">"IMEI"</string>
    <string name="meid" msgid="3291227361605924674">"MEID"</string>
    <string name="ClipMmi" msgid="4110549342447630629">"ID dohodnega klicatelja"</string>
    <string name="ClirMmi" msgid="4702929460236547156">"ID odhodnega klicatelja"</string>
    <string name="ColpMmi" msgid="4736462893284419302">"ID povezane linije"</string>
    <string name="ColrMmi" msgid="5889782479745764278">"Omejitev ID-ja povezane linije"</string>
    <string name="CfMmi" msgid="8390012691099787178">"Preusmerjanje klicev"</string>
    <string name="CwMmi" msgid="3164609577675404761">"Čakajoči klic"</string>
    <string name="BaMmi" msgid="7205614070543372167">"Zapora klicev"</string>
    <string name="PwdMmi" msgid="3360991257288638281">"Sprememba gesla"</string>
    <string name="PinMmi" msgid="7133542099618330959">"Sprememba kode PIN"</string>
    <string name="CnipMmi" msgid="4897531155968151160">"Klicna številka je prisotna"</string>
    <string name="CnirMmi" msgid="885292039284503036">"Klicna številka je omejena"</string>
    <string name="ThreeWCMmi" msgid="2436550866139999411">"Trismerno klicanje"</string>
    <string name="RuacMmi" msgid="1876047385848991110">"Zavrnitev neželenih, motečih klicev"</string>
    <string name="CndMmi" msgid="185136449405618437">"Dostava na klicno številko"</string>
    <string name="DndMmi" msgid="8797375819689129800">"Ne moti"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="4511621022859867988">"ID klicatelja je ponastavljen na omejeno. Naslednji klic: omejeno"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="5036749051007098105">"ID klicatelja je ponastavljen na omejeno. Naslednji klic: ni omejeno"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="1022781126694885017">"ID klicatelja je ponastavljen na neomejeno. Naslednji klic: omejeno"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2491576172356463443">"ID klicatelja je ponastavljen na neomejeno. Naslednji klic: ni omejeno"</string>
    <string name="serviceNotProvisioned" msgid="8289333510236766193">"Storitev ni nastavljena in omogočena."</string>
    <string name="CLIRPermanent" msgid="166443681876381118">"Ne morete spremeniti nastavitve ID-ja klicatelja."</string>
    <string name="RestrictedOnDataTitle" msgid="1500576417268169774">"Ni mobilne podatkovne storitve"</string>
    <string name="RestrictedOnEmergencyTitle" msgid="2852916906106191866">"Klicanje v sili ni na voljo"</string>
    <string name="RestrictedOnNormalTitle" msgid="7009474589746551737">"Ni storitve za glasovne klice"</string>
    <string name="RestrictedOnAllVoiceTitle" msgid="3982069078579103087">"Ni storitve glasovnega klicanja ali klicanja v sili"</string>
    <string name="RestrictedStateContent" msgid="7693575344608618926">"Operater je začasno izklopil storitev"</string>
    <string name="RestrictedStateContentMsimTemplate" msgid="5228235722511044687">"Operater je začasno izklopil storitev za kartico SIM <xliff:g id="SIMNUMBER">%d</xliff:g>"</string>
    <string name="NetworkPreferenceSwitchTitle" msgid="1008329951315753038">"Mobilnega omrežja ni mogoče doseči"</string>
    <string name="NetworkPreferenceSwitchSummary" msgid="2086506181486324860">"Poskusite spremeniti prednostno omrežje. Dotaknite se, če ga želite spremeniti."</string>
    <string name="EmergencyCallWarningTitle" msgid="1615688002899152860">"Klicanje v sili ni na voljo"</string>
    <string name="EmergencyCallWarningSummary" msgid="1194185880092805497">"Klicev v sili ni mogoče opravljati prek omrežja Wi-Fi"</string>
    <string name="notification_channel_network_alert" msgid="4788053066033851841">"Opozorila"</string>
    <string name="notification_channel_call_forward" msgid="8230490317314272406">"Preusmerjanje klicev"</string>
    <string name="notification_channel_emergency_callback" msgid="54074839059123159">"Način za povratni klic v sili"</string>
    <string name="notification_channel_mobile_data_status" msgid="1941911162076442474">"Stanje prenosa podatkov v mobilnem omrežju"</string>
    <string name="notification_channel_sms" msgid="1243384981025535724">"Sporočila SMS"</string>
    <string name="notification_channel_voice_mail" msgid="8457433203106654172">"Sporočila v odzivniku"</string>
    <string name="notification_channel_wfc" msgid="9048240466765169038">"Klicanje prek Wi-Fi-ja"</string>
    <string name="notification_channel_sim" msgid="5098802350325677490">"Stanje kartice SIM"</string>
    <string name="notification_channel_sim_high_prio" msgid="642361929452850928">"Stanje kartice SIM z visoko stopnjo prednosti"</string>
    <string name="peerTtyModeFull" msgid="337553730440832160">"Enakovredna naprava je zahtevala način TTY FULL"</string>
    <string name="peerTtyModeHco" msgid="5626377160840915617">"Enakovredna naprava je zahtevala način TTY HCO"</string>
    <string name="peerTtyModeVco" msgid="572208600818270944">"Enakovredna naprava je zahtevala način TTY VCO"</string>
    <string name="peerTtyModeOff" msgid="2420380956369226583">"Enakovredna naprava je zahtevala način TTY OFF"</string>
    <string name="serviceClassVoice" msgid="2065556932043454987">"Govor"</string>
    <string name="serviceClassData" msgid="4148080018967300248">"Podatki"</string>
    <string name="serviceClassFAX" msgid="2561653371698904118">"FAKS"</string>
    <string name="serviceClassSMS" msgid="1547664561704509004">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="2029856900898545984">"Asinhrono"</string>
    <string name="serviceClassDataSync" msgid="7895071363569133704">"Sinhronizacija"</string>
    <string name="serviceClassPacket" msgid="1430642951399303804">"Paket"</string>
    <string name="serviceClassPAD" msgid="6850244583416306321">"PAD"</string>
    <string name="roamingText0" msgid="7793257871609854208">"Indikator za gostovanje je vklopljen"</string>
    <string name="roamingText1" msgid="5073028598334616445">"Indikator za gostovanje je izklopljen"</string>
    <string name="roamingText2" msgid="2834048284153110598">"Indikator gostovanja utripa"</string>
    <string name="roamingText3" msgid="831690234035748988">"Zunaj soseske"</string>
    <string name="roamingText4" msgid="2171252529065590728">"Zunaj stavbe"</string>
    <string name="roamingText5" msgid="4294671587635796641">"Gostovanje – prednostni sistem"</string>
    <string name="roamingText6" msgid="5536156746637992029">"Gostovanje – razpoložljiv sistem"</string>
    <string name="roamingText7" msgid="1783303085512907706">"Gostovanje – Alliance Partner"</string>
    <string name="roamingText8" msgid="7774800704373721973">"Gostovanje – Premium Partner"</string>
    <string name="roamingText9" msgid="1933460020190244004">"Gostovanje – popolno delovanje storitve"</string>
    <string name="roamingText10" msgid="7434767033595769499">"Gostovanje – delno delovanje storitve"</string>
    <string name="roamingText11" msgid="5245687407203281407">"Pasica gostovanja je vklopljena"</string>
    <string name="roamingText12" msgid="673537506362152640">"Pasica za gostovanje je izklopljena"</string>
    <string name="roamingTextSearching" msgid="5323235489657753486">"Iskanje storitve"</string>
    <string name="wfcRegErrorTitle" msgid="3193072971584858020">"Klicanja prek Wi-Fi-ja ni bilo mogoče nastaviti"</string>
  <string-array name="wfcOperatorErrorAlertMessages">
    <item msgid="468830943567116703">"Če želite klicati ali pošiljati sporočila prek omrežja Wi-Fi, se najprej obrnite na operaterja, da nastavi to storitev. Nato v nastavitvah znova vklopite klicanje prek omrežja Wi-Fi. (Koda napake: <xliff:g id="CODE">%1$s</xliff:g>)"</item>
  </string-array>
  <string-array name="wfcOperatorErrorNotificationMessages">
    <item msgid="4795145070505729156">"Težava pri registriranju klicanja prek Wi-Fi-ja pri operaterju: <xliff:g id="CODE">%1$s</xliff:g>"</item>
  </string-array>
    <!-- no translation found for wfcSpnFormat_spn (2982505428519096311) -->
    <skip />
    <string name="wfcSpnFormat_spn_wifi_calling" msgid="3165949348000906194">"Klicanje prek Wi-Fi-ja operaterja <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_wifi_calling_vo_hyphen" msgid="3836827895369365298">"Klicanje prek Wi‑Fi-ja pri operaterju <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_wlan_call" msgid="4895315549916165700">"Klic prek omrežja WLAN"</string>
    <string name="wfcSpnFormat_spn_wlan_call" msgid="255919245825481510">"Klic prek omrežja WLAN operaterja <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_wifi" msgid="7232899594327126970">"Wi-Fi operaterja <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_wifi_calling_bar_spn" msgid="8383917598312067365">"Klicanje prek WiFi-ja | <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_vowifi" msgid="6865214948822061486">"Govor prek Wi-Fi-ja operaterja <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_wifi_calling" msgid="6178935388378661755">"Klicanje prek Wi-Fi-ja"</string>
    <string name="wfcSpnFormat_wifi" msgid="1376356951297043426">"Wi-Fi"</string>
    <string name="wfcSpnFormat_wifi_calling_wo_hyphen" msgid="7178561009225028264">"Klicanje prek Wi-Fi-ja"</string>
    <string name="wfcSpnFormat_vowifi" msgid="8371335230890725606">"Govor prek Wi-Fi-ja"</string>
    <string name="wifi_calling_off_summary" msgid="5626710010766902560">"Izklopljeno"</string>
    <string name="wfc_mode_wifi_preferred_summary" msgid="1035175836270943089">"Klic prek omrežja Wi-Fi"</string>
    <string name="wfc_mode_cellular_preferred_summary" msgid="4958965609212575619">"Klic prek mobilnega omrežja"</string>
    <string name="wfc_mode_wifi_only_summary" msgid="104951993894678665">"Samo Wi-Fi"</string>
    <string name="cfTemplateNotForwarded" msgid="862202427794270501">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: ni posredovano"</string>
    <string name="cfTemplateForwarded" msgid="9132506315842157860">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g>"</string>
    <string name="cfTemplateForwardedTime" msgid="735042369233323609">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g> po toliko sekundah: <xliff:g id="TIME_DELAY">{2}</xliff:g>"</string>
    <string name="cfTemplateRegistered" msgid="5619930473441550596">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: ni posredovano"</string>
    <string name="cfTemplateRegisteredTime" msgid="5222794399642525045">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: ni posredovano"</string>
    <string name="fcComplete" msgid="1080909484660507044">"Koda funkcije je dokončana."</string>
    <string name="fcError" msgid="5325116502080221346">"Težava s povezavo ali neveljavna koda funkcije."</string>
    <string name="httpErrorOk" msgid="6206751415788256357">"V redu"</string>
    <string name="httpError" msgid="3406003584150566720">"Napaka v omrežju."</string>
    <string name="httpErrorLookup" msgid="3099834738227549349">"URL-ja ni bilo mogoče najti."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="3976195595501606787">"Shema preverjanja pristnosti mesta ni podprta."</string>
    <string name="httpErrorAuth" msgid="469553140922938968">"Pristnosti ni bilo mogoče preveriti."</string>
    <string name="httpErrorProxyAuth" msgid="7229662162030113406">"Preverjanje pristnosti s strežnikom proxy ni bilo uspešno."</string>
    <string name="httpErrorConnect" msgid="3295081579893205617">"Povezave s strežnikom ni bilo mogoče vzpostaviti."</string>
    <string name="httpErrorIO" msgid="3860318696166314490">"S strežnikom ni bilo mogoče komunicirati. Poskusite znova pozneje."</string>
    <string name="httpErrorTimeout" msgid="7446272815190334204">"Časovna omejitev za povezavo s strežnikom je potekla."</string>
    <string name="httpErrorRedirectLoop" msgid="8455757777509512098">"Na tej strani je preveč preusmeritev strežnika."</string>
    <string name="httpErrorUnsupportedScheme" msgid="2664108769858966374">"Protokol ni podprt."</string>
    <string name="httpErrorFailedSslHandshake" msgid="546319061228876290">"Varne povezave ni bilo mogoče vzpostaviti."</string>
    <string name="httpErrorBadUrl" msgid="754447723314832538">"Strani ni mogoče odpreti, ker URL ni veljaven."</string>
    <string name="httpErrorFile" msgid="3400658466057744084">"Do datoteke ni bilo mogoče dostopati."</string>
    <string name="httpErrorFileNotFound" msgid="5191433324871147386">"Zahtevane datoteke ni bilo mogoče najti."</string>
    <string name="httpErrorTooManyRequests" msgid="2149677715552037198">"V obdelavi je preveč zahtev. Poskusite znova pozneje."</string>
    <string name="notification_title" msgid="5783748077084481121">"Napaka pri prijavi v račun <xliff:g id="ACCOUNT">%1$s</xliff:g>"</string>
    <string name="contentServiceSync" msgid="2341041749565687871">"Sinhronizacija"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="5766411446676388623">"Ni mogoče sinhronizirati"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="4562226280528716090">"Poskusili ste izbrisati preveč vsebine vrste <xliff:g id="CONTENT_TYPE">%s</xliff:g>."</string>
    <string name="low_memory" product="tablet" msgid="5557552311566179924">"Pomnilnik tabličnega računalnika je poln. Izbrišite nekaj datotek, da sprostite prostor."</string>
    <string name="low_memory" product="watch" msgid="3479447988234030194">"Shramba ure je polna. Izbrišite nekaj datotek, da sprostite prostor."</string>
    <string name="low_memory" product="tv" msgid="6663680413790323318">"Shramba naprave Android TV je polna. Izbrišite nekaj datotek, da sprostite prostor."</string>
    <string name="low_memory" product="default" msgid="2539532364144025569">"Pomnilnik telefona je poln. Izbrišite nekaj datotek, da sprostite prostor."</string>
    <plurals name="ssl_ca_cert_warning" formatted="false" msgid="2288194355006173029">
      <item quantity="one">Nameščeni so overitelji potrdil</item>
      <item quantity="two">Nameščeni so overitelji potrdil</item>
      <item quantity="few">Nameščeni so overitelji potrdil</item>
      <item quantity="other">Nameščeni so overitelji potrdil</item>
    </plurals>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4961102218216815242">"Neznana tretja oseba"</string>
    <string name="ssl_ca_cert_noti_by_administrator" msgid="4564941950768783879">"Nadzira skrbnik delovnega profila"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="217337232273211674">"Nadzira: <xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="work_profile_deleted" msgid="5891181538182009328">"Delovni profil izbrisan"</string>
    <string name="work_profile_deleted_details" msgid="3773706828364418016">"Skrbniška aplikacija delovnega profila manjka ali pa je poškodovana, zaradi česar je bil delovni profil s povezanimi podatki izbrisan. Za pomoč se obrnite na skrbnika."</string>
    <string name="work_profile_deleted_description_dpm_wipe" msgid="2477244968924647232">"Vaš delovni profil ni več na voljo v tej napravi"</string>
    <string name="work_profile_deleted_reason_maximum_password_failure" msgid="1080323158315663167">"Preveč poskusov vnosa gesla"</string>
    <string name="device_ownership_relinquished" msgid="4080886992183195724">"Skrbnik je napravo prepustil osebni uporabi"</string>
    <string name="network_logging_notification_title" msgid="554983187553845004">"Naprava je upravljana"</string>
    <string name="network_logging_notification_text" msgid="1327373071132562512">"Vaša organizacija upravlja to napravo in lahko nadzira omrežni promet. Dotaknite se za podrobnosti."</string>
    <string name="location_changed_notification_title" msgid="3620158742816699316">"Aplikacije imajo dostop do vaše lokacije"</string>
    <string name="location_changed_notification_text" msgid="7158423339982706912">"Za več informacij se obrnite na skrbnika za IT"</string>
    <string name="country_detector" msgid="7023275114706088854">"Zaznavalnik države"</string>
    <string name="location_service" msgid="2439187616018455546">"Lokacijska storitev"</string>
    <string name="sensor_notification_service" msgid="7474531979178682676">"Storitev obvestil tipal"</string>
    <string name="twilight_service" msgid="8964898045693187224">"Storitev Somrak"</string>
    <string name="factory_reset_warning" msgid="6858705527798047809">"Podatki v napravi bodo izbrisani"</string>
    <string name="factory_reset_message" msgid="2657049595153992213">"Skrbniške aplikacije ni mogoče uporabljati. Podatki v napravi bodo izbrisani.\n\nČe imate vprašanja, se obrnite na skrbnika organizacije."</string>
    <string name="printing_disabled_by" msgid="3517499806528864633">"Tiskanje je onemogočil pravilnik <xliff:g id="OWNER_APP">%s</xliff:g>."</string>
    <string name="personal_apps_suspension_title" msgid="7561416677884286600">"Vklopite delovni profil"</string>
    <string name="personal_apps_suspension_text" msgid="6115455688932935597">"Osebne aplikacije so blokirane, dokler ne vklopite delovnega profila"</string>
    <string name="personal_apps_suspension_tomorrow_text" msgid="6322541302153673994">"Osebne aplikacije bodo blokirane jutri"</string>
    <string name="personal_apps_suspended_turn_profile_on" msgid="4278188538997940785">"Vklopi delovni profil"</string>
    <string name="me" msgid="6207584824693813140">"Jaz"</string>
    <string name="power_dialog" product="tablet" msgid="8333207765671417261">"Možnosti tabličnega računalnika"</string>
    <string name="power_dialog" product="tv" msgid="7792839006640933763">"Možnosti naprave Android TV"</string>
    <string name="power_dialog" product="default" msgid="1107775420270203046">"Možnosti telefona"</string>
    <string name="silent_mode" msgid="8796112363642579333">"Tihi način"</string>
    <string name="turn_on_radio" msgid="2961717788170634233">"Vklopi brezžično omrežje"</string>
    <string name="turn_off_radio" msgid="7222573978109933360">"Izklopi brezžično omrežje"</string>
    <string name="screen_lock" msgid="2072642720826409809">"Zaklep zaslona"</string>
    <string name="power_off" msgid="4111692782492232778">"Izklopi"</string>
    <string name="silent_mode_silent" msgid="5079789070221150912">"Izklopi zvonjenje"</string>
    <string name="silent_mode_vibrate" msgid="8821830448369552678">"Zvonjenje z vibriranjem"</string>
    <string name="silent_mode_ring" msgid="6039011004781526678">"Vklopi zvonjenje"</string>
    <string name="reboot_to_update_title" msgid="2125818841916373708">"Posodobitev sistema Android"</string>
    <string name="reboot_to_update_prepare" msgid="6978842143587422365">"Pripravljanje na posodobitev …"</string>
    <string name="reboot_to_update_package" msgid="4644104795527534811">"Obdelava paketa za posodobitev …"</string>
    <string name="reboot_to_update_reboot" msgid="4474726009984452312">"Vnovičen zagon …"</string>
    <string name="reboot_to_reset_title" msgid="2226229680017882787">"Ponastavitev na tovarniške nastavitve"</string>
    <string name="reboot_to_reset_message" msgid="3347690497972074356">"Vnovičen zagon …"</string>
    <string name="shutdown_progress" msgid="5017145516412657345">"Se zaustavlja ..."</string>
    <string name="shutdown_confirm" product="tablet" msgid="2872769463279602432">"Tablični računalnik se bo zaustavil."</string>
    <string name="shutdown_confirm" product="tv" msgid="7975942887313518330">"Naprava Android TV se bo zaustavila."</string>
    <string name="shutdown_confirm" product="watch" msgid="2977299851200240146">"Ura se bo izklopila."</string>
    <string name="shutdown_confirm" product="default" msgid="136816458966692315">"Telefon bo zaustavljen."</string>
    <string name="shutdown_confirm_question" msgid="796151167261608447">"Ali želite izklopiti napravo?"</string>
    <string name="reboot_safemode_title" msgid="5853949122655346734">"Vnovičen zagon v varnem načinu"</string>
    <string name="reboot_safemode_confirm" msgid="1658357874737219624">"Ali želite znova zagnati v varnem načinu? S tem onemogočite vse nameščene aplikacije drugih ponudnikov. Obnovljene bodo pri naslednjem vnovičnem zagonu."</string>
    <string name="recent_tasks_title" msgid="8183172372995396653">"Nedavno"</string>
    <string name="no_recent_tasks" msgid="9063946524312275906">"Ni nedavnih aplikacij"</string>
    <string name="global_actions" product="tablet" msgid="4412132498517933867">"Možnosti tabličnega računalnika"</string>
    <string name="global_actions" product="tv" msgid="3871763739487450369">"Možnosti naprave Android TV"</string>
    <string name="global_actions" product="default" msgid="6410072189971495460">"Možnosti telefona"</string>
    <string name="global_action_lock" msgid="6949357274257655383">"Zaklep zaslona"</string>
    <string name="global_action_power_off" msgid="4404936470711393203">"Izklopi"</string>
    <string name="global_action_power_options" msgid="1185286119330160073">"Vklop/izklop"</string>
    <string name="global_action_restart" msgid="4678451019561687074">"Znova zaženi"</string>
    <string name="global_action_emergency" msgid="1387617624177105088">"Klic v sili"</string>
    <string name="global_action_bug_report" msgid="5127867163044170003">"Poročilo o napakah"</string>
    <string name="global_action_logout" msgid="6093581310002476511">"Končaj sejo"</string>
    <string name="global_action_screenshot" msgid="2610053466156478564">"Posnetek"</string>
    <string name="bugreport_title" msgid="8549990811777373050">"Poročilo o napakah"</string>
    <string name="bugreport_message" msgid="5212529146119624326">"S tem bodo zbrani podatki o trenutnem stanju naprave, ki bodo poslani v e-poštnem sporočilu. Izvedba poročila o napakah in priprava trajata nekaj časa, zato bodite potrpežljivi."</string>
    <string name="bugreport_option_interactive_title" msgid="7968287837902871289">"Interaktivno poročilo"</string>
    <string name="bugreport_option_interactive_summary" msgid="8493795476325339542">"To možnost uporabite v večini primerov. Omogoča spremljanje poteka poročila, vnos več podrobnosti o težavi in snemanje posnetkov zaslona. Morda bodo izpuščeni nekateri redkeje uporabljani razdelki, za katere je poročanje dolgotrajno."</string>
    <string name="bugreport_option_full_title" msgid="7681035745950045690">"Celotno poročilo"</string>
    <string name="bugreport_option_full_summary" msgid="1975130009258435885">"To možnost uporabite za najmanj motenj sistema, če je naprava neodzivna ali prepočasna oziroma ko potrebujete vse razdelke poročila. Ne omogoča vnosa več podrobnosti ali snemanja dodatnih posnetkov zaslona."</string>
    <plurals name="bugreport_countdown" formatted="false" msgid="3906120379260059206">
      <item quantity="one">Posnetek zaslona za poročilo o napakah bo narejen čez <xliff:g id="NUMBER_1">%d</xliff:g> s.</item>
      <item quantity="two">Posnetek zaslona za poročilo o napakah bo narejen čez <xliff:g id="NUMBER_1">%d</xliff:g> s.</item>
      <item quantity="few">Posnetek zaslona za poročilo o napakah bo narejen čez <xliff:g id="NUMBER_1">%d</xliff:g> s.</item>
      <item quantity="other">Posnetek zaslona za poročilo o napakah bo narejen čez <xliff:g id="NUMBER_1">%d</xliff:g> s.</item>
    </plurals>
    <string name="bugreport_screenshot_success_toast" msgid="7986095104151473745">"Posnetek zaslona s poročilom o napakah je izdelan"</string>
    <string name="bugreport_screenshot_failure_toast" msgid="6736320861311294294">"Izdelava posnetka zaslona s poročilom o napakah ni uspela"</string>
    <string name="global_action_toggle_silent_mode" msgid="8464352592860372188">"Tihi način"</string>
    <string name="global_action_silent_mode_on_status" msgid="2371892537738632013">"Zvok je IZKLOPLJEN"</string>
    <string name="global_action_silent_mode_off_status" msgid="6608006545950920042">"Zvok je VKLOPLJEN"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="6911684460146916206">"Način za letalo"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="5508025516695361936">"Način za letalo je VKLOPLJEN"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="8522219771500505475">"Način za letalo je IZKLOPLJEN"</string>
    <string name="global_action_settings" msgid="4671878836947494217">"Nastavitve"</string>
    <string name="global_action_assist" msgid="2517047220311505805">"Pomoč"</string>
    <string name="global_action_voice_assist" msgid="6655788068555086695">"Glas. pomočnik"</string>
    <string name="global_action_lockdown" msgid="2475471405907902963">"Zakleni"</string>
    <string name="status_bar_notification_info_overflow" msgid="3330152558746563475">"999 +"</string>
    <string name="notification_hidden_text" msgid="2835519769868187223">"Novo obvestilo"</string>
    <string name="notification_channel_virtual_keyboard" msgid="6465975799223304567">"Navidezna tipkovnica"</string>
    <string name="notification_channel_physical_keyboard" msgid="5417306456125988096">"Fizična tipkovnica"</string>
    <string name="notification_channel_security" msgid="8516754650348238057">"Varnost"</string>
    <string name="notification_channel_car_mode" msgid="2123919247040988436">"Način za avtomobil"</string>
    <string name="notification_channel_account" msgid="6436294521740148173">"Stanje računa"</string>
    <string name="notification_channel_developer" msgid="1691059964407549150">"Sporočila razvijalcev"</string>
    <string name="notification_channel_developer_important" msgid="7197281908918789589">"Pomembna sporočila razvijalcem"</string>
    <string name="notification_channel_updates" msgid="7907863984825495278">"Posodobitve"</string>
    <string name="notification_channel_network_status" msgid="2127687368725272809">"Stanje omrežja"</string>
    <string name="notification_channel_network_alerts" msgid="6312366315654526528">"Opozorila omrežja"</string>
    <string name="notification_channel_network_available" msgid="6083697929214165169">"Omrežje je na voljo"</string>
    <string name="notification_channel_vpn" msgid="1628529026203808999">"Stanje omrežja VPN"</string>
    <string name="notification_channel_device_admin" msgid="6384932669406095506">"Opozorila skrbnika za IT"</string>
    <string name="notification_channel_alerts" msgid="5070241039583668427">"Opozorila"</string>
    <string name="notification_channel_retail_mode" msgid="3732239154256431213">"Predstavitev za maloprodajo"</string>
    <string name="notification_channel_usb" msgid="1528280969406244896">"Povezava USB"</string>
    <string name="notification_channel_heavy_weight_app" msgid="17455756500828043">"Aplikacija se izvaja"</string>
    <string name="notification_channel_foreground_service" msgid="7102189948158885178">"Aplikacije, ki porabljajo energijo baterije"</string>
    <string name="foreground_service_app_in_background" msgid="1439289699671273555">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> porablja energijo baterije"</string>
    <string name="foreground_service_apps_in_background" msgid="7340037176412387863">"Toliko aplikacij porablja energijo baterije: <xliff:g id="NUMBER">%1$d</xliff:g>"</string>
    <string name="foreground_service_tap_for_details" msgid="9078123626015586751">"Dotaknite se za prikaz podrobnosti porabe baterije in prenosa podatkov"</string>
    <string name="foreground_service_multiple_separator" msgid="5002287361849863168">"<xliff:g id="LEFT_SIDE">%1$s</xliff:g>, <xliff:g id="RIGHT_SIDE">%2$s</xliff:g>"</string>
    <string name="safeMode" msgid="8974401416068943888">"Varni način"</string>
    <string name="android_system_label" msgid="5974767339591067210">"Sistem Android"</string>
    <string name="user_owner_label" msgid="8628726904184471211">"Preklopi na osebni profil"</string>
    <string name="managed_profile_label" msgid="7316778766973512382">"Preklopi na delovni profil"</string>
    <string name="permgrouplab_contacts" msgid="4254143639307316920">"Stiki"</string>
    <string name="permgroupdesc_contacts" msgid="9163927941244182567">"dostop do stikov"</string>
    <string name="permgrouplab_location" msgid="1858277002233964394">"Lokacija"</string>
    <string name="permgroupdesc_location" msgid="1995955142118450685">"dostop do lokacije te naprave"</string>
    <string name="permgrouplab_calendar" msgid="6426860926123033230">"Koledar"</string>
    <string name="permgroupdesc_calendar" msgid="6762751063361489379">"dostop do koledarja"</string>
    <string name="permgrouplab_sms" msgid="795737735126084874">"SMS"</string>
    <string name="permgroupdesc_sms" msgid="5726462398070064542">"pošiljanje in ogled sporočil SMS"</string>
    <string name="permgrouplab_storage" msgid="1938416135375282333">"Datoteke in predstavnost"</string>
    <string name="permgroupdesc_storage" msgid="6351503740613026600">"dostop do fotografij, predstavnosti in datotek v napravi"</string>
    <string name="permgrouplab_microphone" msgid="2480597427667420076">"Mikrofon"</string>
    <string name="permgroupdesc_microphone" msgid="1047786732792487722">"snemanje zvoka"</string>
    <string name="permgrouplab_activityRecognition" msgid="3324466667921775766">"Telesna dejavnost"</string>
    <string name="permgroupdesc_activityRecognition" msgid="4725624819457670704">"dostop do vaše telesne dejavnosti"</string>
    <string name="permgrouplab_camera" msgid="9090413408963547706">"Fotoaparat"</string>
    <string name="permgroupdesc_camera" msgid="7585150538459320326">"fotografiranje in snemanje videoposnetkov"</string>
    <string name="permgrouplab_calllog" msgid="7926834372073550288">"Dnevniki klicev"</string>
    <string name="permgroupdesc_calllog" msgid="2026996642917801803">"branje in zapisovanje dnevnika klicev v telefonu"</string>
    <string name="permgrouplab_phone" msgid="570318944091926620">"Telefon"</string>
    <string name="permgroupdesc_phone" msgid="270048070781478204">"opravljanje in upravljanje telefonskih klicev"</string>
    <string name="permgrouplab_sensors" msgid="9134046949784064495">"Tipala telesnih funkcij"</string>
    <string name="permgroupdesc_sensors" msgid="2610631290633747752">"dostop do podatkov tipala o vaših vitalnih znakih"</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="7554282892101587296">"Pridobiti vsebino okna"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="6195610527625237661">"Preverjanje vsebine okna, ki ga uporabljate."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="327598364696316213">"Vklopiti raziskovanje z dotikom"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="4394677060796752976">"Elementi, ki se jih dotaknete, bodo izrečeni na glas, zaslon pa lahko raziskujete s potezami."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2772371671541753254">"Opazovati besedilo, ki ga natipkate"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="2381315802405773092">"Vključuje osebne podatke, kot so številke kreditnih kartic in gesla."</string>
    <string name="capability_title_canControlMagnification" msgid="7701572187333415795">"Nadzirati povečave prikaza"</string>
    <string name="capability_desc_canControlMagnification" msgid="2206586716709254805">"Nadziranje stopnje povečave in položaja prikaza."</string>
    <string name="capability_title_canPerformGestures" msgid="9106545062106728987">"Izvajati poteze"</string>
    <string name="capability_desc_canPerformGestures" msgid="6619457251067929726">"Mogoče je izvajanje dotikov, vlečenja, primikanja in razmikanja prstov ter drugih potez."</string>
    <string name="capability_title_canCaptureFingerprintGestures" msgid="1189053104594608091">"Poteze po tipalu prstnih odtisov"</string>
    <string name="capability_desc_canCaptureFingerprintGestures" msgid="6861869337457461274">"Prepoznava poteze, narejene po tipalu prstnih odtisov naprave."</string>
    <string name="capability_title_canTakeScreenshot" msgid="3895812893130071930">"Ustvarjanje posnetka zaslona"</string>
    <string name="capability_desc_canTakeScreenshot" msgid="7762297374317934052">"Lahko naredi posnetek zaslona."</string>
    <string name="permlab_statusBar" msgid="8798267849526214017">"onemogočanje ali spreminjanje vrstice stanja"</string>
    <string name="permdesc_statusBar" msgid="5809162768651019642">"Aplikacijam omogoča onemogočenje vrstice stanja ali dodajanje in odstranjevanje ikon sistema."</string>
    <string name="permlab_statusBarService" msgid="2523421018081437981">"postane vrstica stanja"</string>
    <string name="permdesc_statusBarService" msgid="6652917399085712557">"Aplikaciji omogoča, da postane vrstica stanja."</string>
    <string name="permlab_expandStatusBar" msgid="1184232794782141698">"razširjanje/strnjevanje vrstice stanja"</string>
    <string name="permdesc_expandStatusBar" msgid="7180756900448498536">"Aplikaciji omogoča razširjanje ali strnjevanje vrstice stanja."</string>
    <string name="permlab_install_shortcut" msgid="7451554307502256221">"nameščanje bližnjic"</string>
    <string name="permdesc_install_shortcut" msgid="4476328467240212503">"Aplikaciji omogoča dodajanje bližnjic na začetni zaslon brez posredovanja uporabnika."</string>
    <string name="permlab_uninstall_shortcut" msgid="295263654781900390">"odstranjevanje bližnjic"</string>
    <string name="permdesc_uninstall_shortcut" msgid="1924735350988629188">"Aplikaciji omogoča odstranjevanje bližnjic z začetnega zaslona brez posredovanja uporabnika."</string>
    <string name="permlab_processOutgoingCalls" msgid="4075056020714266558">"preusmeritev odhodnih klicev"</string>
    <string name="permdesc_processOutgoingCalls" msgid="7833149750590606334">"Aplikaciji dovoli ogled klicane številke pri odhodnem klicu in ji omogoča preusmeritev klica na drugo številko ali prekinitev klica."</string>
    <string name="permlab_answerPhoneCalls" msgid="4131324833663725855">"javljanje na telefonske klice"</string>
    <string name="permdesc_answerPhoneCalls" msgid="894386681983116838">"Aplikaciji dovoljuje, da se javi na dohodni telefonski klic."</string>
    <string name="permlab_receiveSms" msgid="505961632050451881">"prejemanje sporočil (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="1797345626687832285">"Aplikaciji omogoča prejemanje in obdelavo SMS-ov. S tem lahko aplikacija nadzoruje ali izbriše sporočila, poslana v napravo, ne da bi vam jih pokazala."</string>
    <string name="permlab_receiveMms" msgid="4000650116674380275">"prejemanje sporočil (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="958102423732219710">"Aplikaciji omogoča prejemanje in obdelavo MMS-ov. S tem lahko aplikacija nadzoruje ali izbriše sporočila, poslana v napravo, ne da bi vam jih pokazala."</string>
    <string name="permlab_bindCellBroadcastService" msgid="586746677002040651">"Posredovanje sporočil oddaj v celici"</string>
    <string name="permdesc_bindCellBroadcastService" msgid="6540910200973641606">"Aplikaciji omogoča povezovanje z modulom za oddaje v celici, da posreduje sporočila oddaj v celici, takoj ko jih prejme. Na nekaterih lokacijah so opozorila oddaj v celici dostavljena, da vas opozorijo na izredne razmere. Zlonamerne aplikacije lahko vplivajo na delovanje naprave, ko prejme sporočilo oddaje v celici."</string>
    <string name="permlab_readCellBroadcasts" msgid="5869884450872137693">"branje sporočil oddaje v celici"</string>
    <string name="permdesc_readCellBroadcasts" msgid="672513437331980168">"Omogoča aplikaciji branje sporočil oddaje v celici, ki jih prejme naprava. Opozorila oddaje v celici so dostavljena na nekaterih lokacijah, da vas opozorijo na izredne razmere. Zlonamerne aplikacije lahko vplivajo na delovanje naprave, ko dobi sporočilo oddaje v celici."</string>
    <string name="permlab_subscribedFeedsRead" msgid="217624769238425461">"branje naročenih virov"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="6911349196661811865">"Aplikaciji omogoča dobivanje podrobnosti o trenutno sinhroniziranih virih."</string>
    <string name="permlab_sendSms" msgid="7757368721742014252">"pošiljanje in ogled sporočil SMS"</string>
    <string name="permdesc_sendSms" msgid="6757089798435130769">"Aplikaciji omogoča pošiljanje SMS-ov. Zaradi tega lahko pride do nepričakovanih stroškov. Zlonamerne aplikacije lahko pošiljajo sporočila brez vaše potrditve, kar vas lahko drago stane."</string>
    <string name="permlab_readSms" msgid="5164176626258800297">"branje sporočil (SMS ali MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="7912990447198112829">"Ta aplikacija lahko prebere vsa sporočila SMS, ki so shranjena v tabličnem računalniku."</string>
    <string name="permdesc_readSms" product="tv" msgid="3054753345758011986">"Ta aplikacija lahko prebere vsa sporočila SMS, shranjena v napravi Android TV."</string>
    <string name="permdesc_readSms" product="default" msgid="774753371111699782">"Ta aplikacija lahko prebere vsa sporočila SMS, ki so shranjena v telefonu."</string>
    <string name="permlab_receiveWapPush" msgid="4223747702856929056">"prejemanje sporočil (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="1638677888301778457">"Aplikaciji omogoča prejemanje in obdelavo sporočil WAP. S tem lahko aplikacija nadzoruje ali izbriše sporočila, poslana v napravo, ne da bi vam jih pokazala."</string>
    <string name="permlab_getTasks" msgid="7460048811831750262">"dobivanje aplikacij, ki se izvajajo"</string>
    <string name="permdesc_getTasks" msgid="7388138607018233726">"Aplikaciji omogoča prejemanje podatkov o trenutnih in nedavno izvajajočih se opravilih. S tem lahko aplikacija odkrije podatke o aplikacijah, ki se uporabljajo v napravi."</string>
    <string name="permlab_manageProfileAndDeviceOwners" msgid="639849495253987493">"upravljanje lastnikov profilov in lastnikov naprave"</string>
    <string name="permdesc_manageProfileAndDeviceOwners" msgid="7304240671781989283">"Dovolite aplikacijam, da nastavijo lastnike profilov in lastnika naprave."</string>
    <string name="permlab_reorderTasks" msgid="7598562301992923804">"preurejanje aplikacij, ki se izvajajo"</string>
    <string name="permdesc_reorderTasks" msgid="8796089937352344183">"Aplikaciji omogoča premikanje opravil v ospredje in ozadje. Aplikacija lahko to naredi brez vašega nadzora."</string>
    <string name="permlab_enableCarMode" msgid="893019409519325311">"omogočanje načina delovanja v avtomobilu"</string>
    <string name="permdesc_enableCarMode" msgid="56419168820473508">"Aplikaciji dovoljuje omogočanje načina za avto."</string>
    <string name="permlab_killBackgroundProcesses" msgid="6559320515561928348">"zapiranje drugih aplikacij"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="2357013583055434685">"Aplikaciji omogoča, da konča procese v ozadju drugih aplikacij. S tem lahko druge aplikacije nehajo delovati."</string>
    <string name="permlab_systemAlertWindow" msgid="5757218350944719065">"Prikaz aplikacije s prekrivanjem drugih aplikacij"</string>
    <string name="permdesc_systemAlertWindow" msgid="1145660714855738308">"Ta aplikacija lahko prekrije druge aplikacije ali druge dele zaslona. To lahko vpliva na normalno delovanje aplikacije in na način prikaza drugih aplikacij."</string>
    <string name="permlab_runInBackground" msgid="541863968571682785">"izvajanje v ozadju"</string>
    <string name="permdesc_runInBackground" msgid="4344539472115495141">"Ta aplikacija se lahko izvaja tudi v ozadju, kar lahko privede do hitrejšega praznjenja baterije."</string>
    <string name="permlab_useDataInBackground" msgid="783415807623038947">"prenos podatkov v ozadju"</string>
    <string name="permdesc_useDataInBackground" msgid="1230753883865891987">"Ta aplikacija lahko prenaša podatke tudi v ozadju, kar lahko privede do večje porabe prenosa podatkov."</string>
    <string name="permlab_persistentActivity" msgid="464970041740567970">"neprekinjeno izvajanje aplikacij"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="6055271149187369916">"Aplikaciji omogoča, da nekatere svoje dele naredi trajne v pomnilniku. S tem je lahko pomnilnik omejen za druge aplikacije, zaradi česar je delovanje tabličnega računalnika upočasnjeno."</string>
    <string name="permdesc_persistentActivity" product="tv" msgid="6800526387664131321">"Aplikaciji dovoljuje, da so nekateri njeni deli trajno prisotni v pomnilniku. S tem je zmanjšana razpoložljivost pomnilnika za druge aplikacije, zaradi česar je delovanje naprave Android TV upočasnjeno."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="1914841924366562051">"Aplikaciji omogoča, da nekatere svoje dele naredi trajne v pomnilniku. S tem je lahko pomnilnik omejen za druge aplikacije, zaradi česar je delovanje telefona upočasnjeno."</string>
    <string name="permlab_foregroundService" msgid="1768855976818467491">"Izvajanje storitve v ospredju"</string>
    <string name="permdesc_foregroundService" msgid="8720071450020922795">"Aplikaciji dovoljuje uporabo storitev v ospredju."</string>
    <string name="permlab_getPackageSize" msgid="375391550792886641">"izračunavanje prostora za shranjevanje aplikacije"</string>
    <string name="permdesc_getPackageSize" msgid="742743530909966782">"Aplikaciji omogoča, da pridobi njeno kodo, podatke in velikosti predpomnilnika."</string>
    <string name="permlab_writeSettings" msgid="8057285063719277394">"spreminjanje sistemskih nastavitev"</string>
    <string name="permdesc_writeSettings" msgid="8293047411196067188">"Aplikaciji omogoča spreminjanje podatkov nastavitev sistema. Zlonamerne aplikacije lahko poškodujejo konfiguracijo sistema."</string>
    <string name="permlab_receiveBootCompleted" msgid="6643339400247325379">"izvedba ob zagonu"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="5565659082718177484">"Aplikaciji omogoča, da se samodejno zažene po zagonu sistema. To lahko povzroči daljši zagon tabličnega računalnika in aplikaciji omogoči, da s stalnim izvajanjem upočasni delovanje tabličnega računalnika."</string>
    <string name="permdesc_receiveBootCompleted" product="tv" msgid="4900842256047614307">"Aplikaciji dovoljuje, da se zažene takoj po zagonu sistema. To lahko povzroči daljši čas zagona naprave Android TV in aplikaciji dovoljuje, da s stalnim izvajanjem upočasni delovanje naprave."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="7912677044558690092">"Aplikaciji omogoča, da se zažene takoj, ko sistem dokonča zagon. Zato lahko zagon telefona traja nekoliko dlje, aplikacija pa lahko upočasni splošno delovanje telefona, ker se vedno izvaja."</string>
    <string name="permlab_broadcastSticky" msgid="4552241916400572230">"pošiljanje fiksne oddaje"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="5058486069846384013">"Aplikaciji omogoča hitro pošiljanje fiksnih oddaj, ki ostanejo po koncu oddajanja. Zaradi prekomerne uporabe je delovanje tabličnega računalnika lahko počasno ali nestabilno, ker porabi preveč pomnilnika."</string>
    <string name="permdesc_broadcastSticky" product="tv" msgid="2338185920171000650">"Aplikaciji dovoljuje pošiljanje fiksnih oddaj, ki ostanejo po koncu oddajanja. Zaradi prekomerne uporabe je delovanje naprave Android TV lahko počasno ali nestabilno, ker porabi preveč pomnilnika."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="134529339678913453">"Aplikaciji omogoča hitro pošiljanje fiksnih oddaj, ki ostanejo po koncu oddajanja. Zaradi prekomerne uporabe je delovanje telefona lahko počasno ali nestabilno, ker porabi preveč pomnilnika."</string>
    <string name="permlab_readContacts" msgid="8776395111787429099">"branje stikov"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="6430093481659992692">"Aplikaciji dovoljuje branje podatkov o stikih, shranjenih v tabličnem računalniku. Aplikacije bodo imele dostop tudi do računov v tabličnem računalniku, ki so ustvarili stike. To lahko vključuje račune, ki so jih ustvarile nameščene aplikacije. S tem dovoljenjem lahko aplikacije shranjujejo podatke o stikih in zlonamerne aplikacije lahko te podatke razkrijejo brez vaše vednosti."</string>
    <string name="permdesc_readContacts" product="tv" msgid="8400138591135554789">"Aplikaciji dovoljuje branje podatkov o stikih, shranjenih v napravi Android TV. Aplikacije bodo imele dostop tudi do računov v napravi Android TV, ki so ustvarili stike. To lahko vključuje račune, ki so jih ustvarile nameščene aplikacije. S tem dovoljenjem lahko aplikacije shranjujejo podatke o stikih in zlonamerne aplikacije lahko te podatke razkrijejo brez vaše vednosti."</string>
    <string name="permdesc_readContacts" product="default" msgid="4911989776203207644">"Aplikaciji dovoljuje branje podatkov o stikih, shranjenih v telefonu. Aplikacije bodo imele dostop tudi do računov v telefonu, ki so ustvarili stike. To lahko vključuje račune, ki so jih ustvarile nameščene aplikacije. S tem dovoljenjem lahko aplikacije shranjujejo podatke o stikih in zlonamerne aplikacije lahko te podatke razkrijejo brez vaše vednosti."</string>
    <string name="permlab_writeContacts" msgid="8919430536404830430">"spreminjanje stikov"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="6422419281427826181">"Aplikaciji dovoljuje spreminjanje podatkov o stikih, shranjenih v tabličnem računalniku. S tem dovoljenjem lahko aplikacije brišejo podatke o stikih."</string>
    <string name="permdesc_writeContacts" product="tv" msgid="6488872735379978935">"Aplikaciji dovoljuje spreminjanje podatkov o stikih, shranjenih v napravi Android TV. S tem dovoljenjem lahko aplikacije brišejo podatke o stikih."</string>
    <string name="permdesc_writeContacts" product="default" msgid="8304795696237065281">"Aplikaciji dovoljuje spreminjanje podatkov o stikih, shranjenih v telefonu. S tem dovoljenjem lahko aplikacije brišejo podatke o stikih."</string>
    <string name="permlab_readCallLog" msgid="1739990210293505948">"branje dnevnika klicev"</string>
    <string name="permdesc_readCallLog" msgid="8964770895425873433">"Ta aplikacija lahko prebere zgodovino klicev."</string>
    <string name="permlab_writeCallLog" msgid="670292975137658895">"pisanje v dnevnik klicev"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="2657525794731690397">"Aplikaciji dovoli spreminjanje dnevnika klicev v tabličnem računalniku, vključno s podatki o dohodnih in odhodnih klicih. Zlonamerne aplikacije lahko tako izbrišejo ali spreminjajo vaš dnevnik klicev."</string>
    <string name="permdesc_writeCallLog" product="tv" msgid="3934939195095317432">"Aplikaciji dovoljuje spreminjanje dnevnika klicev v napravi Android TV, vključno s podatki o dohodnih in odhodnih klicih. Zlonamerne aplikacije lahko tako izbrišejo ali spreminjajo vaš dnevnik klicev."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="5903033505665134802">"Aplikaciji dovoli spreminjanje dnevnika klicev v telefonu, vključno s podatki o dohodnih in odhodnih klicih. Zlonamerne aplikacije lahko tako izbrišejo ali spreminjajo vaš dnevnik klicev."</string>
    <string name="permlab_bodySensors" msgid="3411035315357380862">"dostop do tipal telesnih funkcij (npr. merilnikov srčnega utripa)"</string>
    <string name="permdesc_bodySensors" product="default" msgid="2365357960407973997">"Aplikaciji omogoča dostop do podatkov tipal, ki nadzirajo vaše fizično stanje, med drugim vaš srčni utrip."</string>
    <string name="permlab_readCalendar" msgid="6408654259475396200">"Branje dogodkov v koledarjih in podrobnosti koledarjev"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="515452384059803326">"Ta aplikacija lahko prebere vse dogodke v koledarju, ki so shranjeni v tabličnem računalniku, ter shrani podatke koledarja ali jih deli z drugimi."</string>
    <string name="permdesc_readCalendar" product="tv" msgid="5811726712981647628">"Ta aplikacija lahko prebere vse dogodke v koledarju, ki so shranjeni v napravi Android TV, ter shrani podatke koledarja ali jih da v skupno rabo z drugimi."</string>
    <string name="permdesc_readCalendar" product="default" msgid="9118823807655829957">"Ta aplikacija lahko prebere vse dogodke v koledarju, ki so shranjeni v telefonu, ter shrani podatke koledarja ali jih deli z drugimi."</string>
    <string name="permlab_writeCalendar" msgid="6422137308329578076">"dodajanje ali spreminjanje dogodkov v koledarju in pošiljanje e-pošte gostom brez vedenja lastnikov"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="8722230940717092850">"Ta aplikacija lahko dodaja, odstranjuje in spreminja dogodke v koledarju, ki so shranjeni v tabličnem računalniku. Ta aplikacija lahko pošilja sporočila, ki bodo morda videti, kot da prihajajo od lastnikov koledarjev, ali spreminja dogodke brez vednosti lastnikov."</string>
    <string name="permdesc_writeCalendar" product="tv" msgid="951246749004952706">"Ta aplikacija lahko dodaja, odstranjuje in spreminja dogodke v koledarju, ki so shranjeni v napravi Android TV. Ta aplikacija lahko pošilja sporočila, ki bodo morda videti, kot da prihajajo od lastnikov koledarjev, ali spreminja dogodke brez vednosti lastnikov."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="5416380074475634233">"Ta aplikacija lahko dodaja, odstranjuje in spreminja dogodke v koledarju, ki so shranjeni v telefonu. Ta aplikacija lahko pošilja sporočila, ki bodo morda videti, kot da prihajajo od lastnikov koledarjev, ali spreminja dogodke brez vednosti lastnikov."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="5162339812057983988">"dostopanje do ukazov ponudnika dodatnih lokacij"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="355369611979907967">"Aplikaciji omogoča dostop do dodatnih ukazov ponudnika lokacij. S tem lahko aplikacija moti delovanje sistema GPS ali drugih virov lokacije."</string>
    <string name="permlab_accessFineLocation" msgid="6426318438195622966">"dostop do točne lokacije samo, ko deluje v ospredju"</string>
    <string name="permdesc_accessFineLocation" msgid="6732174080240016335">"Ta aplikacija lahko pridobi vašo natančno lokacijo od lokacijskih storitev, ko je aplikacija v uporabi. Lokacijske storitve za napravo morajo biti vklopljene, da lahko aplikacija pridobi lokacijo. To lahko poveča porabo energije baterije."</string>
    <string name="permlab_accessCoarseLocation" msgid="1561042925407799741">"dostop do približne lokacije samo, ko deluje v ospredju"</string>
    <string name="permdesc_accessCoarseLocation" msgid="778521847873199160">"Ta aplikacija lahko pridobi vašo približno lokacijo od lokacijskih storitev, ko je aplikacija v uporabi. Lokacijske storitve za napravo morajo biti vklopljene, da lahko aplikacija pridobi lokacijo."</string>
    <string name="permlab_accessBackgroundLocation" msgid="1721164702777366138">"dostop do lokacije med izvajanjem v ozadju"</string>
    <string name="permdesc_accessBackgroundLocation" msgid="8264885066095638105">"Ta aplikacija lahko kadar koli dostopa do lokacije, tudi če aplikacije ne uporabljate."</string>
    <string name="permlab_modifyAudioSettings" msgid="6129039778010031815">"spreminjanje nastavitev zvoka"</string>
    <string name="permdesc_modifyAudioSettings" msgid="8687227609663124921">"Aplikaciji omogoča spreminjanje splošnih zvočnih nastavitev, na primer glasnost in kateri zvočnik se uporablja."</string>
    <string name="permlab_recordAudio" msgid="1208457423054219147">"snemanje zvoka"</string>
    <string name="permdesc_recordAudio" msgid="3976213377904701093">"Ta aplikacija lahko poljubno uporablja mikrofon za snemanje zvoka."</string>
    <string name="permlab_sim_communication" msgid="176788115994050692">"pošiljanje ukazov na kartico SIM"</string>
    <string name="permdesc_sim_communication" msgid="4179799296415957960">"Aplikaciji dovoli pošiljanje ukazov kartici SIM. To je lahko zelo nevarno."</string>
    <string name="permlab_activityRecognition" msgid="1782303296053990884">"prepoznavanje telesne dejavnosti"</string>
    <string name="permdesc_activityRecognition" msgid="8667484762991357519">"Ta aplikacija lahko prepoznava vašo telesno dejavnost."</string>
    <string name="permlab_camera" msgid="6320282492904119413">"fotografiranje in snemanje videoposnetkov"</string>
    <string name="permdesc_camera" msgid="1354600178048761499">"Ta aplikacija lahko poljubno uporablja fotoaparat za snemanje fotografij ali videoposnetkov."</string>
    <string name="permlab_systemCamera" msgid="3642917457796210580">"Aplikaciji ali storitvi dovoli dostop do vgrajenih fotoaparatov za snemanje fotografij in videoposnetkov"</string>
    <string name="permdesc_systemCamera" msgid="5938360914419175986">"Ta prednostna ali sistemska aplikacija lahko z vgrajenim fotoaparatom kadar koli snema fotografije in videoposnetke. Aplikacija mora imeti omogočeno tudi dovoljenje android.permission.CAMERA"</string>
    <string name="permlab_cameraOpenCloseListener" msgid="5548732769068109315">"Aplikaciji ali storitvi dovoli prejemanje povratnih klicev o odpiranju ali zapiranju naprav s fotoaparati."</string>
    <string name="permdesc_cameraOpenCloseListener" msgid="2002636131008772908">"Ta aplikacija lahko prejema povratne klice, ko se odpira (s katero aplikacijo) ali zapira katera koli naprava s fotoaparatom."</string>
    <string name="permlab_vibrate" msgid="8596800035791962017">"nadzor vibriranja"</string>
    <string name="permdesc_vibrate" msgid="8733343234582083721">"Aplikaciji omogoča nadzor vibriranja."</string>
    <string name="permdesc_vibrator_state" msgid="7050024956594170724">"Aplikaciji dovoljuje dostop do stanja vibriranja."</string>
    <string name="permlab_callPhone" msgid="1798582257194643320">"neposredno klicanje telefonskih številk"</string>
    <string name="permdesc_callPhone" msgid="5439809516131609109">"Aplikaciji omogoča klicanje telefonskih številk brez vašega posredovanja. Zaradi tega lahko pride do nepričakovanih stroškov ali klicev. Aplikaciji to ne dovoljuje opravljanja klicev v sili. Zlonamerne aplikacije lahko kličejo brez vaše potrditve, kar vas lahko drago stane."</string>
    <string name="permlab_accessImsCallService" msgid="442192920714863782">"dostop do storitve za klicanje IMS"</string>
    <string name="permdesc_accessImsCallService" msgid="6328551241649687162">"Aplikaciji dovoljuje uporabo storitev IMS za opravljanje klicev brez vašega posredovanja."</string>
    <string name="permlab_readPhoneState" msgid="8138526903259297969">"branje stanja in identitete telefona"</string>
    <string name="permdesc_readPhoneState" msgid="7229063553502788058">"Aplikaciji omogoča dostop do funkcij telefona v napravi. S tem dovoljenjem lahko aplikacija določi telefonsko številko in ID-je naprave, določi lahko tudi, ali je klic aktiven, in oddaljeno številko, s katero je klic povezan."</string>
    <string name="permlab_manageOwnCalls" msgid="9033349060307561370">"Usmeri klice prek sistema"</string>
    <string name="permdesc_manageOwnCalls" msgid="4431178362202142574">"Dovoli, da aplikacija usmeri klice prek sistema, da se tako izboljša izkušnja klicanja."</string>
    <string name="permlab_callCompanionApp" msgid="3654373653014126884">"ogled in nadzor klicev prek sistema."</string>
    <string name="permdesc_callCompanionApp" msgid="8474168926184156261">"Aplikaciji dovoljuje, da si ogleda in nadzoruje aktivne klice v napravi. To vključuje informacije, kot so telefonske številke klicev in stanje klicev."</string>
    <string name="permlab_exemptFromAudioRecordRestrictions" msgid="1164725468350759486">"izvzetje iz omejitev pri snemanju zvoka"</string>
    <string name="permdesc_exemptFromAudioRecordRestrictions" msgid="2425117015896871976">"Za aplikacijo ne veljajo omejitve pri snemanju zvoka."</string>
    <string name="permlab_acceptHandover" msgid="2925523073573116523">"Nadaljevanje klica iz druge aplikacije"</string>
    <string name="permdesc_acceptHandovers" msgid="7129026180128626870">"Aplikaciji dovoljuje nadaljevanje klica, ki se je začel v drugi aplikaciji."</string>
    <string name="permlab_readPhoneNumbers" msgid="5668704794723365628">"branje telefonskih številk"</string>
    <string name="permdesc_readPhoneNumbers" msgid="7368652482818338871">"Aplikaciji dovoljuje dostop do telefonskih številk v napravi."</string>
    <string name="permlab_wakeLock" product="automotive" msgid="1904736682319375676">"Ohranjanje vklopljenega zaslona avtomobila"</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1527660973931694000">"preprečitev prehoda tabličnega računalnika v stanje pripravljenosti"</string>
    <string name="permlab_wakeLock" product="tv" msgid="2856941418123343518">"preprečevanje preklopa naprave Android TV v stanje pripravljenosti"</string>
    <string name="permlab_wakeLock" product="default" msgid="569409726861695115">"preprečevanje prehoda v stanje pripravljenosti telefona"</string>
    <string name="permdesc_wakeLock" product="automotive" msgid="5995045369683254571">"Aplikaciji omogoča, da zaslon avtomobila ohranja vklopljen."</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="2441742939101526277">"Omogoča, da aplikacija prepreči prehod tabličnega računalnika v stanje pripravljenosti."</string>
    <string name="permdesc_wakeLock" product="tv" msgid="2329298966735118796">"Aplikaciji dovoljuje, da prepreči preklop naprave Android TV v stanje pripravljenosti."</string>
    <string name="permdesc_wakeLock" product="default" msgid="3689523792074007163">"Aplikaciji omogoča, da v telefonu prepreči prehod v stanje pripravljenosti."</string>
    <string name="permlab_transmitIr" msgid="8077196086358004010">"prenašanje z infrardečim oddajnikom"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5884738958581810253">"Aplikaciji dovoljuje uporabo infrardečega oddajnika tabličnega računalnika."</string>
    <string name="permdesc_transmitIr" product="tv" msgid="3278506969529173281">"Aplikaciji dovoljuje uporabo infrardečega oddajnika v napravi Android TV."</string>
    <string name="permdesc_transmitIr" product="default" msgid="8484193849295581808">"Aplikaciji dovoljuje uporabo infrardečega oddajnika telefona."</string>
    <string name="permlab_setWallpaper" msgid="6959514622698794511">"nastavljanje ozadja"</string>
    <string name="permdesc_setWallpaper" msgid="2973996714129021397">"Aplikaciji omogoča nastavitev ozadja sistema."</string>
    <string name="permlab_setWallpaperHints" msgid="1153485176642032714">"prilagajanje velikosti slike za ozadje"</string>
    <string name="permdesc_setWallpaperHints" msgid="6257053376990044668">"Aplikaciji omogoča nastavitev namigov o velikosti ozadja sistema."</string>
    <string name="permlab_setTimeZone" msgid="7922618798611542432">"nastavitev časovnega pasu"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1788868809638682503">"Aplikaciji omogoča spreminjanje časovnega pasu v tabličnem računalniku."</string>
    <string name="permdesc_setTimeZone" product="tv" msgid="9069045914174455938">"Aplikaciji dovoljuje spreminjanje časovnega pasu naprave Android TV."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4611828585759488256">"Aplikaciji omogoča spreminjanje časovnega pasu v telefonu."</string>
    <string name="permlab_getAccounts" msgid="5304317160463582791">"iskanje računov v napravi"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="1784452755887604512">"Aplikaciji omogoča prejemanje seznama računov, ki jih pozna tablični računalnik.To lahko vključuje račune, ki so jih ustvarile nameščene aplikacije."</string>
    <string name="permdesc_getAccounts" product="tv" msgid="437604680436540822">"Aplikaciji dovoljuje pridobivanje seznama računov, ki jih pozna naprava Android TV. To lahko vključuje vse račune, ki so jih ustvarile nameščene aplikacije."</string>
    <string name="permdesc_getAccounts" product="default" msgid="2491273043569751867">"Aplikaciji omogoča prejemanje seznama računov, ki jih pozna telefon.To lahko vključuje račune, ki so jih ustvarile nameščene aplikacije."</string>
    <string name="permlab_accessNetworkState" msgid="2349126720783633918">"prikaz omrežnih povezav"</string>
    <string name="permdesc_accessNetworkState" msgid="4394564702881662849">"Aplikaciji omogoča ogled podatkov o omrežnih povezavah, na primer o obstoječih in povezanih omrežjih."</string>
    <string name="permlab_createNetworkSockets" msgid="3224420491603590541">"poln dostop do omrežja"</string>
    <string name="permdesc_createNetworkSockets" msgid="7722020828749535988">"Aplikaciji omogoča ustvarjanje vtičnic omrežja in uporabo omrežnih protokolov po meri. Brskalnik in druge aplikacije omogočajo pošiljanje podatkov v internet, zato to dovoljenje ni potrebno za pošiljanje podatkov v internet."</string>
    <string name="permlab_changeNetworkState" msgid="8945711637530425586">"spreminjanje povezljivosti omrežja"</string>
    <string name="permdesc_changeNetworkState" msgid="649341947816898736">"Aplikaciji omogoča spreminjanje stanja povezljivosti omrežja."</string>
    <string name="permlab_changeTetherState" msgid="9079611809931863861">"Spreminjanje posredniške povezljivosti"</string>
    <string name="permdesc_changeTetherState" msgid="3025129606422533085">"Aplikaciji dovoljuje spreminjanje stanja povezljivosti posredniškega omrežja."</string>
    <string name="permlab_accessWifiState" msgid="5552488500317911052">"prikaz povezav Wi-Fi"</string>
    <string name="permdesc_accessWifiState" msgid="6913641669259483363">"Aplikaciji omogoča ogled podatkov o omrežjih Wi-Fi, na primer o tem, ali je Wi-Fi omogočen, in imen povezanih naprav Wi-Fi."</string>
    <string name="permlab_changeWifiState" msgid="7947824109713181554">"vzpostavitev povezave z omrežjem Wi-Fi in prekinitev povezave z njim"</string>
    <string name="permdesc_changeWifiState" msgid="7170350070554505384">"Aplikaciji omogoča, da vzpostavi povezavo z dostopnimi točkami Wi-Fi in prekine povezavo z njimi ter spremeni konfiguracijo naprav za omrežja Wi-Fi."</string>
    <string name="permlab_changeWifiMulticastState" msgid="285626875870754696">"dovoljevanje sprejema večvrstnega brezžičnega oddajanja"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="191079868596433554">"Aplikaciji omogoča prejemanje paketov, poslanih v vse naprave v omrežju Wi-Fi z večvrstnimi naslovi, ne samo v vaš tablični računalnik. Poraba je večja kot v načinu delovanja brez večvrstnega oddajanja."</string>
    <string name="permdesc_changeWifiMulticastState" product="tv" msgid="1336952358450652595">"Aplikaciji dovoljuje prejemanje paketov, poslanih v vse naprave v omrežju Wi-Fi z večvrstnimi naslovi, ne samo v vašo napravo Android TV. Poraba je večja kot v načinu delovanja brez večvrstnega oddajanja."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="8296627590220222740">"Aplikaciji omogoča prejemanje paketov, poslanih v vse naprave v omrežju Wi-Fi z večvrstnimi naslovi, ne samo v vaš telefon. Poraba je večja kot v načinu delovanja brez večvrstnega oddajanja."</string>
    <string name="permlab_bluetoothAdmin" msgid="6490373569441946064">"dostop do nastavitev Bluetooth"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="5370837055438574863">"Aplikaciji omogoča konfiguriranje lokalnega tabličnega računalnika Bluetooth ter zaznavanje oddaljenih naprav in združevanje z njimi."</string>
    <string name="permdesc_bluetoothAdmin" product="tv" msgid="1623992984547014588">"Aplikaciji dovoljuje konfiguriranje vmesnika Bluetooth v napravi Android TV ter odkrivanje oddaljenih naprav in seznanjanje z njimi."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="7381341743021234863">"Aplikaciji omogoča konfiguriranje lokalnega telefona s tehnologijo Bluetooth ter odkrivanje oddaljenih naprav in povezovanje z njimi."</string>
    <string name="permlab_accessWimaxState" msgid="7029563339012437434">"vzpostavitev povezave z omrežjem WiMax in prekinitev povezave z njim"</string>
    <string name="permdesc_accessWimaxState" msgid="5372734776802067708">"Aplikaciji omogoča, da ugotovi, ali je WiMAX omogočen, in ogled podatkov o povezanih omrežjih WiMAX."</string>
    <string name="permlab_changeWimaxState" msgid="6223305780806267462">"sprememba stanja omrežja WiMAX"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="4011097664859480108">"Aplikaciji omogoča, da vzpostavi povezavo med tabličnim računalnikom in omrežjem WiMAX ter jo prekine."</string>
    <string name="permdesc_changeWimaxState" product="tv" msgid="5373274458799425276">"Aplikaciji dovoljuje vzpostavitev povezave med napravo Android TV in omrežji WiMAX ter prekinitev te povezave."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="1551666203780202101">"Aplikaciji omogoča, da vzpostavi povezavo med telefonom in omrežjem WiMAX ter jo prekine."</string>
    <string name="permlab_bluetooth" msgid="586333280736937209">"seznanitev z napravami Bluetooth"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3053222571491402635">"Aplikaciji omogoča ogled konfiguracije Bluetootha tabličnega računalnika ter vzpostavljanje in sprejemanje povezave s seznanjenimi napravami."</string>
    <string name="permdesc_bluetooth" product="tv" msgid="8851534496561034998">"Aplikaciji dovoljuje ogled konfiguracije vmesnika Bluetooth v napravi Android TV ter ustvarjanje in sprejemanje povezav s seznanjenimi napravami."</string>
    <string name="permdesc_bluetooth" product="default" msgid="2779606714091276746">"Aplikaciji omogoča ogled konfiguracije Bluetootha telefona ter ustvarjanje in sprejemanje povezave s seznanjenimi napravami."</string>
    <string name="permlab_preferredPaymentInfo" msgid="5274423844767445054">"Podatki o prednostni storitvi za plačevanje prek povezave NFC"</string>
    <string name="permdesc_preferredPaymentInfo" msgid="8583552469807294967">"Aplikaciji omogoča pridobivanje podatkov o prednostni storitvi za plačevanje prek povezave NFC, kot so registrirani pripomočki in cilj preusmeritve."</string>
    <string name="permlab_nfc" msgid="1904455246837674977">"nadzor nad komunikacijo s tehnologijo bližnjega polja"</string>
    <string name="permdesc_nfc" msgid="8352737680695296741">"Podpira komunikacijo med računalnikom in oznakami, karticami in bralniki komunikacije s tehnologijo bližnjega polja."</string>
    <string name="permlab_disableKeyguard" msgid="3605253559020928505">"onemogočanje zaklepanja zaslona"</string>
    <string name="permdesc_disableKeyguard" msgid="3223710003098573038">"Aplikaciji dovoljuje, da onemogoči zaklep tipkovnice in morebitno povezano varnostno geslo. Telefon na primer onemogoči zaklep tipkovnice pri dohodnem klicu ter vnovič omogoči zaklep, ko je klic končan."</string>
    <string name="permlab_requestPasswordComplexity" msgid="1808977190557794109">"zahteva zapletenost zaklepanja zaslona"</string>
    <string name="permdesc_requestPasswordComplexity" msgid="1130556896836258567">"Aplikaciji dovoljuje, da pridobi raven zapletenosti zaklepanja zaslona (visoka, srednja, nizka ali brez), ki označuje možen obseg dolžine in vrsto zaklepanja zaslona. Aplikacija lahko tudi predlaga uporabnikom, da posodobijo zaklepanje zaslona na določeno raven, vendar lahko uporabniki to opozorilo prezrejo in ga zaprejo tako, da se pomaknejo stran. Upoštevajte, da zaklepanje zaslona ni shranjeno v golem besedilu, tako da aplikacija ne pozna točnega gesla."</string>
    <string name="permlab_useBiometric" msgid="6314741124749633786">"uporaba strojne opreme za biometrične podatke"</string>
    <string name="permdesc_useBiometric" msgid="7502858732677143410">"Aplikaciji omogoča uporabo strojne opreme za biometrične podatke za preverjanje pristnosti"</string>
    <string name="permlab_manageFingerprint" msgid="7432667156322821178">"upravljanje strojne opreme za prstne odtise"</string>
    <string name="permdesc_manageFingerprint" msgid="2025616816437339865">"Aplikaciji omogoča sprožanje načinov za dodajanje in brisanje predlog s prstnimi odtisi za uporabo."</string>
    <string name="permlab_useFingerprint" msgid="1001421069766751922">"uporaba strojne opreme za prstne odtise"</string>
    <string name="permdesc_useFingerprint" msgid="412463055059323742">"Aplikaciji omogoča uporabo strojne opreme za prstne odtise za preverjanje pristnosti"</string>
    <string name="permlab_audioWrite" msgid="8501705294265669405">"spreminjanje glasbene zbirke"</string>
    <string name="permdesc_audioWrite" msgid="8057399517013412431">"Aplikaciji omogoča spreminjanje glasbene zbirke."</string>
    <string name="permlab_videoWrite" msgid="5940738769586451318">"spreminjanje zbirke videoposnetkov"</string>
    <string name="permdesc_videoWrite" msgid="6124731210613317051">"Aplikaciji omogoča spreminjanje zbirke videoposnetkov."</string>
    <string name="permlab_imagesWrite" msgid="1774555086984985578">"spreminjanje zbirke fotografij"</string>
    <string name="permdesc_imagesWrite" msgid="5195054463269193317">"Aplikaciji omogoča spreminjanje zbirke fotografij."</string>
    <string name="permlab_mediaLocation" msgid="7368098373378598066">"branje lokacij v predstavnostni zbirki"</string>
    <string name="permdesc_mediaLocation" msgid="597912899423578138">"Aplikaciji omogoča branje lokacij v predstavnostni zbirki."</string>
    <string name="biometric_dialog_default_title" msgid="5284880398508155088">"Potrdite, da ste res vi"</string>
    <string name="biometric_error_hw_unavailable" msgid="2494077380540615216">"Strojna oprema za biometrične podatke ni na voljo"</string>
    <string name="biometric_error_user_canceled" msgid="6732303949695293730">"Preverjanje pristnosti je preklicano"</string>
    <string name="biometric_not_recognized" msgid="5106687642694635888">"Ni prepoznano"</string>
    <string name="biometric_error_canceled" msgid="8266582404844179778">"Preverjanje pristnosti je preklicano"</string>
    <string name="biometric_error_device_not_secured" msgid="3129845065043995924">"Nastavljena ni nobena koda PIN, vzorec ali geslo"</string>
    <string name="fingerprint_acquired_partial" msgid="8532380671091299342">"Zaznan delni prstni odtis. Poskusite znova."</string>
    <string name="fingerprint_acquired_insufficient" msgid="2545149524031515411">"Prstnega odtisa ni bilo mogoče obdelati. Poskusite znova."</string>
    <string name="fingerprint_acquired_imager_dirty" msgid="4694800187151533990">"Tipalo prstnih odtisov je umazano. Očistite ga in poskusite znova."</string>
    <string name="fingerprint_acquired_too_fast" msgid="5151661932298844352">"Prehiter premik prsta. Poskusite znova."</string>
    <string name="fingerprint_acquired_too_slow" msgid="6683510291554497580">"Prepočasen premik prsta. Poskusite znova."</string>
  <string-array name="fingerprint_acquired_vendor">
  </string-array>
    <string name="fingerprint_authenticated" msgid="2024862866860283100">"Pristnost prstnega odtisa je preverjena"</string>
    <string name="face_authenticated_no_confirmation_required" msgid="8867889115112348167">"Pristnost obraza je potrjena"</string>
    <string name="face_authenticated_confirmation_required" msgid="6872632732508013755">"Pristnost obraza je preverjena. Pritisnite gumb »Potrdi«."</string>
    <string name="fingerprint_error_hw_not_available" msgid="4571700896929561202">"Strojna oprema za prstne odtise ni na voljo."</string>
    <string name="fingerprint_error_no_space" msgid="6126456006769817485">"Prstnega odtisa ni mogoče shraniti. Odstranite obstoječi prstni odtis."</string>
    <string name="fingerprint_error_timeout" msgid="2946635815726054226">"Dosežena časovna omejitev za prstni odtis. Poskusite znova."</string>
    <string name="fingerprint_error_canceled" msgid="540026881380070750">"Dejanje s prstnim odtisom je bilo preklicano."</string>
    <string name="fingerprint_error_user_canceled" msgid="7685676229281231614">"Dejanje s prstnim odtisom je preklical uporabnik."</string>
    <string name="fingerprint_error_lockout" msgid="7853461265604738671">"Preveč poskusov. Poskusite znova pozneje."</string>
    <string name="fingerprint_error_lockout_permanent" msgid="3895478283943513746">"Preveč poskusov. Tipalo prstnih odtisov je onemogočeno."</string>
    <string name="fingerprint_error_unable_to_process" msgid="1148553603490048742">"Poskusite znova."</string>
    <string name="fingerprint_error_no_fingerprints" msgid="8671811719699072411">"Ni registriranih prstnih odtisov."</string>
    <string name="fingerprint_error_hw_not_present" msgid="578914350967423382">"Ta naprava nima tipala prstnih odtisov."</string>
    <string name="fingerprint_error_security_update_required" msgid="7750187320640856433">"Tipalo je začasno onemogočeno."</string>
    <string name="fingerprint_name_template" msgid="8941662088160289778">"Prst <xliff:g id="FINGERID">%d</xliff:g>"</string>
  <string-array name="fingerprint_error_vendor">
  </string-array>
    <string name="fingerprint_icon_content_description" msgid="4741068463175388817">"Ikona prstnih odtisov"</string>
    <string name="permlab_manageFace" msgid="4569549381889283282">"upravljanje strojne opreme za odklepanje z obrazom"</string>
    <string name="permdesc_manageFace" msgid="6204569688492710471">"Aplikaciji omogoča sprožanje načinov za dodajanje in brisanje predlog z obrazi za uporabo."</string>
    <string name="permlab_useFaceAuthentication" msgid="1011430526454859030">"uporaba strojne opreme za odklepanje z obrazom"</string>
    <string name="permdesc_useFaceAuthentication" msgid="3115697017684668012">"Aplikaciji omogoča uporabo strojne opreme za odklepanje z obrazom za preverj. pristnosti"</string>
    <string name="face_recalibrate_notification_name" msgid="6006095897989257026">"Odklepanje z obrazom"</string>
    <string name="face_recalibrate_notification_title" msgid="5944930528030496897">"Znova registrirajte obraz"</string>
    <string name="face_recalibrate_notification_content" msgid="892757485125249962">"Za izboljšanje prepoznavanja znova registrirajte svoj obraz"</string>
    <string name="face_acquired_insufficient" msgid="2150805835949162453">"Točnih podatkov o obrazu ni bilo mogoče zajeti. Poskusite znova."</string>
    <string name="face_acquired_too_bright" msgid="8070756048978079164">"Presvetlo. Poskusite z blažjo osvetlitvijo."</string>
    <string name="face_acquired_too_dark" msgid="252573548464426546">"Pretemno. Poskusite z močnejšo osvetlitvijo."</string>
    <string name="face_acquired_too_close" msgid="1628767882971469833">"Telefon nekoliko odmaknite."</string>
    <string name="face_acquired_too_far" msgid="5098567726427173896">"Bolj približajte telefon."</string>
    <string name="face_acquired_too_high" msgid="4868033653626081839">"Telefon pomaknite višje."</string>
    <string name="face_acquired_too_low" msgid="1512237819632165945">"Telefon premaknite nižje."</string>
    <string name="face_acquired_too_right" msgid="2513391513020932655">"Telefon premaknite v levo."</string>
    <string name="face_acquired_too_left" msgid="8882499346502714350">"Telefon premaknite v desno."</string>
    <string name="face_acquired_poor_gaze" msgid="4427153558773628020">"Glejte bolj naravnost v napravo."</string>
    <string name="face_acquired_not_detected" msgid="2945945257956443257">"Obraz nastavite naravnost pred telefon."</string>
    <string name="face_acquired_too_much_motion" msgid="8199691445085189528">"Preveč se premikate. Držite telefon pri miru."</string>
    <string name="face_acquired_recalibrate" msgid="8724013080976469746">"Znova registrirajte svoj obraz."</string>
    <string name="face_acquired_too_different" msgid="4699657338753282542">"Obraza ni več mogoče prepoznati. Poskusite znova."</string>
    <string name="face_acquired_too_similar" msgid="7684650785108399370">"Preveč podobno, spremenite položaj."</string>
    <string name="face_acquired_pan_too_extreme" msgid="7822191262299152527">"Glejte malce bolj naravnost."</string>
    <string name="face_acquired_tilt_too_extreme" msgid="8119978324129248059">"Malce manj nagnite glavo."</string>
    <string name="face_acquired_roll_too_extreme" msgid="1442830503572636825">"Glejte malce bolj naravnost."</string>
    <string name="face_acquired_obscured" msgid="4917643294953326639">"Umaknite vse, kar vam morda zakriva obraz."</string>
    <string name="face_acquired_sensor_dirty" msgid="8968391891086721678">"Očistite vrhnji del zaslona, vključno s črno vrstico"</string>
  <string-array name="face_acquired_vendor">
  </string-array>
    <string name="face_error_hw_not_available" msgid="5085202213036026288">"Obraza ni mogoče preveriti. Str. opr. ni na voljo."</string>
    <string name="face_error_timeout" msgid="522924647742024699">"Znova izvedite odklepanje z obrazom."</string>
    <string name="face_error_no_space" msgid="5649264057026021723">"Novega obraza ni mogoče shraniti. Najprej izbrišite starega."</string>
    <string name="face_error_canceled" msgid="2164434737103802131">"Dejanje z obrazom je bilo preklicano."</string>
    <string name="face_error_user_canceled" msgid="8553045452825849843">"Odklepanje z obrazom je preklical uporabnik."</string>
    <string name="face_error_lockout" msgid="7864408714994529437">"Preveč poskusov. Poskusite znova pozneje."</string>
    <string name="face_error_lockout_permanent" msgid="8277853602168960343">"Preveč poskusov. Odklepanje z obrazom je onemogočeno."</string>
    <string name="face_error_unable_to_process" msgid="5723292697366130070">"Obraza ni mogoče preveriti. Poskusite znova."</string>
    <string name="face_error_not_enrolled" msgid="7369928733504691611">"Odklepanja z obrazom niste nastavili."</string>
    <string name="face_error_hw_not_present" msgid="1070600921591729944">"Ta naprava ne podpira odklepanja z obrazom."</string>
    <string name="face_error_security_update_required" msgid="5076017208528750161">"Tipalo je začasno onemogočeno."</string>
    <string name="face_name_template" msgid="3877037340223318119">"Obraz <xliff:g id="FACEID">%d</xliff:g>"</string>
  <string-array name="face_error_vendor">
  </string-array>
    <string name="face_icon_content_description" msgid="465030547475916280">"Ikona obraza"</string>
    <string name="permlab_readSyncSettings" msgid="6250532864893156277">"branje nastavitev sinhronizacije"</string>
    <string name="permdesc_readSyncSettings" msgid="1325658466358779298">"Aplikaciji omogoča branje nastavitev sinhronizacije za račun. S tem lahko aplikacija na primer ugotovi, ali je aplikacija Ljudje sinhronizirana z računom."</string>
    <string name="permlab_writeSyncSettings" msgid="6583154300780427399">"vklop in izklop sinhronizacije"</string>
    <string name="permdesc_writeSyncSettings" msgid="6029151549667182687">"Aplikaciji omogoča spreminjanje nastavitev sinhronizacije za račun. S tem se lahko na primer omogoči sinhronizacijo aplikacije Ljudje z računom."</string>
    <string name="permlab_readSyncStats" msgid="3747407238320105332">"branje statističnih podatkov sinhronizacije"</string>
    <string name="permdesc_readSyncStats" msgid="3867809926567379434">"Aplikaciji omogoča branje statističnih podatkov o sinhronizaciji za račun, vključno z zgodovino dogodkov sinhronizacije in količino sinhroniziranih podatkov."</string>
    <string name="permlab_sdcardRead" msgid="5791467020950064920">"branje vsebine skupne shrambe"</string>
    <string name="permdesc_sdcardRead" msgid="6872973242228240382">"Aplikaciji omogoča branje vsebine skupne shrambe."</string>
    <string name="permlab_sdcardWrite" msgid="4863021819671416668">"spreminjanje ali brisanje vsebine skupne shrambe"</string>
    <string name="permdesc_sdcardWrite" msgid="8376047679331387102">"Aplikaciji omogoča zapisovanje vsebine skupne shrambe."</string>
    <string name="permlab_use_sip" msgid="8250774565189337477">"opravljanje/sprejemanje klicev SIP"</string>
    <string name="permdesc_use_sip" msgid="3590270893253204451">"Aplikaciji omogoča opravljanje in sprejemanje klicev SIP."</string>
    <string name="permlab_register_sim_subscription" msgid="1653054249287576161">"registriranje novih telekomunikacijskih povezav s kartico SIM"</string>
    <string name="permdesc_register_sim_subscription" msgid="4183858662792232464">"Aplikaciji omogoča registriranje novih telekomunikacijskih povezav s kartico SIM."</string>
    <string name="permlab_register_call_provider" msgid="6135073566140050702">"registriranje novih telekomunikacijskih povezav"</string>
    <string name="permdesc_register_call_provider" msgid="4201429251459068613">"Aplikaciji omogoča registriranje novih telekomunikacijskih povezav."</string>
    <string name="permlab_connection_manager" msgid="3179365584691166915">"upravljanje telekomunikacijskih povezav"</string>
    <string name="permdesc_connection_manager" msgid="1426093604238937733">"Aplikaciji omogoča upravljanje telekomunikacijskih povezav."</string>
    <string name="permlab_bind_incall_service" msgid="5990625112603493016">"interakcija z zaslonom pri klicu"</string>
    <string name="permdesc_bind_incall_service" msgid="4124917526967765162">"Aplikaciji omogoča nadzor nad tem, kdaj in kako uporabnik vidi zaslon pri klicu."</string>
    <string name="permlab_bind_connection_service" msgid="5409268245525024736">"uporaba telefonskih storitev"</string>
    <string name="permdesc_bind_connection_service" msgid="6261796725253264518">"Aplikaciji omogoča uporabo telefonskih storitev za klicanje/sprejemanje klicev."</string>
    <string name="permlab_control_incall_experience" msgid="6436863486094352987">"zagotavljanje uporabniške izkušnje med klicem"</string>
    <string name="permdesc_control_incall_experience" msgid="5896723643771737534">"Aplikaciji omogoča zagotavljanje uporabniške izkušnje med klicem."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="8470402862501573795">"branje prejšnje uporabe omrežja"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="1112962304941637102">"Aplikaciji omogoča branje pretekle uporabe omrežja za določena omrežja in aplikacije."</string>
    <string name="permlab_manageNetworkPolicy" msgid="6872549423152175378">"upravljanje pravilnika o omrežju"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="1865663268764673296">"Aplikaciji omogoča upravljanje pravilnikov o omrežju in določanje pravil za aplikacijo."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="7448790834938749041">"spremeni obračunavanje uporabe omrežja"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5076042642247205390">"Aplikaciji omogoča, da spremeni uporabo omrežja na podlagi aplikacij. Ni za uporabo z navadnimi aplikacijami."</string>
    <string name="permlab_accessNotifications" msgid="7130360248191984741">"dostop do obvestil"</string>
    <string name="permdesc_accessNotifications" msgid="761730149268789668">"Dovoli aplikaciji, da prenese, razišče in izbriše obvestila, tudi tista, ki so jih objavile druge aplikacije."</string>
    <string name="permlab_bindNotificationListenerService" msgid="5848096702733262458">"poveži se s storitvijo poslušalca obvestil"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="4970553694467137126">"Lastniku omogoča povezovanje z vmesnikom storitve poslušalca obvestil najvišje ravni. Tega nikoli ni treba uporabiti za navadne aplikacije."</string>
    <string name="permlab_bindConditionProviderService" msgid="5245421224814878483">"povezovanje s storitvijo ponudnika pogojev"</string>
    <string name="permdesc_bindConditionProviderService" msgid="6106018791256120258">"Imetniku omogoča povezovanje z vmesnikom storitve ponudnika pogojev najvišje ravni. Tega ni treba nikoli uporabiti za navadne aplikacije."</string>
    <string name="permlab_bindDreamService" msgid="4776175992848982706">"povezava s storitvijo sanjarjenja"</string>
    <string name="permdesc_bindDreamService" msgid="9129615743300572973">"Imetniku omogoča povezovanje z vmesnikom storitve sanjarjenja najvišje ravni. Tega ni treba nikoli uporabiti za navadne aplikacije."</string>
    <string name="permlab_invokeCarrierSetup" msgid="5098810760209818140">"sprožitev operaterjeve aplikacije za konfiguracijo"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4790845896063237887">"Lastniku omogoča sproženje operaterjeve aplikacije za konfiguracijo. Tega nikoli ni treba uporabiti za navadne aplikacije."</string>
    <string name="permlab_accessNetworkConditions" msgid="1270732533356286514">"spremljanje razmer v omrežju"</string>
    <string name="permdesc_accessNetworkConditions" msgid="2959269186741956109">"Aplikaciji omogoča spremljanje razmer v omrežju. Pri navadnih aplikacijah to ne bi smelo biti potrebno."</string>
    <string name="permlab_setInputCalibration" msgid="932069700285223434">"sprememba umerjanja vhodne naprave"</string>
    <string name="permdesc_setInputCalibration" msgid="2937872391426631726">"Aplikaciji dovoli spreminjanje parametrov za umerjanje zaslona na dotik. Tega ni treba nikoli uporabiti za navadne aplikacije."</string>
    <string name="permlab_accessDrmCertificates" msgid="6473765454472436597">"dostop do potrdil za upravljanje digitalnih pravic"</string>
    <string name="permdesc_accessDrmCertificates" msgid="6983139753493781941">"Aplikaciji omogoča pripravo in uporabo potrdil za upravljanje digitalnih pravic. To naj ne bi bilo nikoli potrebno za običajne aplikacije."</string>
    <string name="permlab_handoverStatus" msgid="7620438488137057281">"prejemanje stanja prenosov s funkcijo Android Beam"</string>
    <string name="permdesc_handoverStatus" msgid="3842269451732571070">"Omogoči tej aplikaciji prejemanje podatkov o trenutnih prenosih s funkcijo Android Beam"</string>
    <string name="permlab_removeDrmCertificates" msgid="710576248717404416">"odstranjevanje potrdil za upravljanje digitalnih pravic"</string>
    <string name="permdesc_removeDrmCertificates" msgid="4068445390318355716">"Aplikaciji omogoča odstranjevanje potrdil za upravljanje digitalnih pravic. Tega ni treba nikoli uporabiti za navadne aplikacije."</string>
    <string name="permlab_bindCarrierMessagingService" msgid="3363450860593096967">"povezovanje z operaterjevo sporočilno storitvijo"</string>
    <string name="permdesc_bindCarrierMessagingService" msgid="6316457028173478345">"Imetniku omogoča povezovanje z vmesnikom operaterjeve sporočilne storitve najvišje ravni. To naj ne bi bilo nikoli potrebno za navadne aplikacije."</string>
    <string name="permlab_bindCarrierServices" msgid="2395596978626237474">"povezovanje z operaterjevimi storitvami"</string>
    <string name="permdesc_bindCarrierServices" msgid="9185614481967262900">"Imetniku omogoča povezovanje z operaterjevimi storitvami. Tega ni treba nikoli uporabiti za navadne aplikacije."</string>
    <string name="permlab_access_notification_policy" msgid="5524112842876975537">"dostop do načina »ne moti«"</string>
    <string name="permdesc_access_notification_policy" msgid="8538374112403845013">"Aplikaciji omogoča branje in pisanje konfiguracije načina »ne moti«."</string>
    <string name="permlab_startViewPermissionUsage" msgid="1504564328641112341">"začetek uporabe dovoljenja za ogledovanje"</string>
    <string name="permdesc_startViewPermissionUsage" msgid="2820325605959586538">"Imetniku omogoča začetek uporabe dovoljenj za aplikacijo. Nikoli ni potrebno za navadne aplikacije."</string>
    <string name="policylab_limitPassword" msgid="4851829918814422199">"Nastavitev pravil za geslo"</string>
    <string name="policydesc_limitPassword" msgid="4105491021115793793">"Nadzor nad dolžino in znaki, ki so dovoljeni v geslih in kodah PIN za odklepanje zaslona."</string>
    <string name="policylab_watchLogin" msgid="7599669460083719504">"Nadzor nad poskusi odklepanja zaslona"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="2388436408621909298">"Nadzoruje število nepravilno vnesenih gesel pri odklepanju zaslona in zaklene tablični računalnik ali izbriše vse podatke v njem, če je vnesenih preveč nepravilnih gesel."</string>
    <string name="policydesc_watchLogin" product="tv" msgid="2140588224468517507">"Nadzira število vnesenih nepravilnih gesel pri odklepanju zaslona in zaklene napravo Android TV ali izbriše vse podatke v napravi Android TV, če je vnesenih preveč nepravilnih gesel."</string>
    <string name="policydesc_watchLogin" product="default" msgid="4885030206253600299">"Spremljajte število vnesenih napačnih gesel, s katerimi želite odkleniti zaslon. Če je teh vnosov preveč, zaklenite telefon ali izbrišite vse podatke v njem."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="tablet" msgid="2049038943004297474">"Nadzira število vnesenih nepravilnih gesel pri odklepanju zaslona in zaklene tablični računalnik ali izbriše vse podatke lastnika, če je vnesenih preveč nepravilnih gesel."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="tv" msgid="8965224107449407052">"Nadzira število vnesenih nepravilnih gesel pri odklepanju zaslona in zaklene napravo Android TV ali izbriše vse podatke tega uporabnika, če je vnesenih preveč nepravilnih gesel."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="default" msgid="9177645136475155924">"Nadzira število vnesenih nepravilnih gesel pri odklepanju zaslona in zaklene telefon ali izbriše vse podatke lastnika, če je vnesenih preveč nepravilnih gesel."</string>
    <string name="policylab_resetPassword" msgid="214556238645096520">"Spreminjanje zaklepanja zaslona"</string>
    <string name="policydesc_resetPassword" msgid="4626419138439341851">"Spreminjanje zaklepanja zaslona."</string>
    <string name="policylab_forceLock" msgid="7360335502968476434">"Zaklepanje zaslona"</string>
    <string name="policydesc_forceLock" msgid="1008844760853899693">"Nadzor nad tem, kako in kdaj se zaklene zaslon."</string>
    <string name="policylab_wipeData" msgid="1359485247727537311">"Brisanje vseh podatkov"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="7245372676261947507">"Izbris podatkov v tabličnem računalniku brez opozorila s ponastavitvijo na tovarniške nastavitve"</string>
    <string name="policydesc_wipeData" product="tv" msgid="513862488950801261">"Brisanje podatkov v napravi Android TV z izvedbo ponastavitve na privzete tovarniške nastavitve brez opozorila."</string>
    <string name="policydesc_wipeData" product="default" msgid="8036084184768379022">"Izbris podatkov v telefonu brez opozorila s ponastavitvijo na tovarniške nastavitve."</string>
    <string name="policylab_wipeData_secondaryUser" msgid="413813645323433166">"Izbris podatkov uporabnika"</string>
    <string name="policydesc_wipeData_secondaryUser" product="tablet" msgid="2336676480090926470">"Izbris podatkov uporabnika v tem tabličnem računalniku brez opozorila."</string>
    <string name="policydesc_wipeData_secondaryUser" product="tv" msgid="2293713284515865200">"Izbris podatkov uporabnika v tej napravi Android TV brez opozorila."</string>
    <string name="policydesc_wipeData_secondaryUser" product="default" msgid="2788325512167208654">"Izbris podatkov uporabnika v tem telefonu brez opozorila."</string>
    <string name="policylab_setGlobalProxy" msgid="215332221188670221">"Nastavitev globalnega strežnika proxy za napravo"</string>
    <string name="policydesc_setGlobalProxy" msgid="7149665222705519604">"Nastavitev globalnega strežnika proxy naprave, ki bo v uporabi, ko je pravilnik omogočen. Samo lastnik naprave lahko nastavi globalni strežnik proxy."</string>
    <string name="policylab_expirePassword" msgid="6015404400532459169">"Nastavitev poteka gesla za zaklepanje zaslona"</string>
    <string name="policydesc_expirePassword" msgid="9136524319325960675">"Spreminjanje tega, kako pogosto je treba spremeniti geslo, kodo PIN ali vzorec za zaklepanje zaslona."</string>
    <string name="policylab_encryptedStorage" msgid="9012936958126670110">"Nastavitev šifriranja shrambe"</string>
    <string name="policydesc_encryptedStorage" msgid="1102516950740375617">"Shranjeni podatki aplikacije morajo biti šifrirani."</string>
    <string name="policylab_disableCamera" msgid="5749486347810162018">"Onemogočanje fotoaparatov"</string>
    <string name="policydesc_disableCamera" msgid="3204405908799676104">"Prepreči uporabo vseh fotoaparatov v napravi."</string>
    <string name="policylab_disableKeyguardFeatures" msgid="5071855750149949741">"Onemogočanje nekaterih funkcij zaklepanja zaslona"</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="6641673177041195957">"Prepreči uporabo nekaterih funkcij zaklepanja zaslona."</string>
  <string-array name="phoneTypes">
    <item msgid="8996339953292723951">"Dom"</item>
    <item msgid="7740243458912727194">"Mobilni telefon"</item>
    <item msgid="8526146065496663766">"Služba"</item>
    <item msgid="8150904584178569699">"Službeni faks"</item>
    <item msgid="4537253139152229577">"Domači faks"</item>
    <item msgid="6751245029698664340">"Pozivnik"</item>
    <item msgid="1692790665884224905">"Drugo"</item>
    <item msgid="6216981255272016212">"Po meri"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="7786349763648997741">"Dom"</item>
    <item msgid="435564470865989199">"Služba"</item>
    <item msgid="4199433197875490373">"Drugo"</item>
    <item msgid="3233938986670468328">"Po meri"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="3861463339764243038">"Dom"</item>
    <item msgid="5472578890164979109">"Služba"</item>
    <item msgid="5718921296646594739">"Drugo"</item>
    <item msgid="5523122236731783179">"Po meri"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="588088543406993772">"Dom"</item>
    <item msgid="5503060422020476757">"Služba"</item>
    <item msgid="2530391194653760297">"Drugo"</item>
    <item msgid="7640927178025203330">"Po meri"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="6144047813304847762">"Služba"</item>
    <item msgid="7402720230065674193">"Drugo"</item>
    <item msgid="808230403067569648">"Po meri"</item>
  </string-array>
  <string-array name="imProtocols">
    <item msgid="7535761744432206400">"AIM"</item>
    <item msgid="2236558491789293993">"Windows Live"</item>
    <item msgid="4925858989398000295">"Yahoo"</item>
    <item msgid="5203383604393320577">"Skype"</item>
    <item msgid="6142060795155127001">"QQ"</item>
    <item msgid="8831467252725610081">"Google Talk"</item>
    <item msgid="4717545739447438044">"ICQ"</item>
    <item msgid="8293711853624033835">"Jabber"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="5120365721260686814">"Po meri"</string>
    <string name="phoneTypeHome" msgid="3880132427643623588">"Dom"</string>
    <string name="phoneTypeMobile" msgid="1178852541462086735">"Mobilni telefon"</string>
    <string name="phoneTypeWork" msgid="6604967163358864607">"Služba"</string>
    <string name="phoneTypeFaxWork" msgid="6757519896109439123">"Službeni faks"</string>
    <string name="phoneTypeFaxHome" msgid="6678559953115904345">"Domači faks"</string>
    <string name="phoneTypePager" msgid="576402072263522767">"Pozivnik"</string>
    <string name="phoneTypeOther" msgid="6918196243648754715">"Drugo"</string>
    <string name="phoneTypeCallback" msgid="3455781500844157767">"Povratni klic"</string>
    <string name="phoneTypeCar" msgid="4604775148963129195">"Avto"</string>
    <string name="phoneTypeCompanyMain" msgid="4482773154536455441">"Podjetje (glavna št.)"</string>
    <string name="phoneTypeIsdn" msgid="2496238954533998512">"ISDN"</string>
    <string name="phoneTypeMain" msgid="5199722006991000111">"Glavna št."</string>
    <string name="phoneTypeOtherFax" msgid="3037145630364770357">"Drugi faks"</string>
    <string name="phoneTypeRadio" msgid="2637819130239264771">"Radio"</string>
    <string name="phoneTypeTelex" msgid="2558783611711876562">"Telefaks"</string>
    <string name="phoneTypeTtyTdd" msgid="532038552105328779">"TTY TDD"</string>
    <string name="phoneTypeWorkMobile" msgid="7522314392003565121">"Služba (mobilni telefon)"</string>
    <string name="phoneTypeWorkPager" msgid="3748332310638505234">"Službeni pozivnik"</string>
    <string name="phoneTypeAssistant" msgid="757550783842231039">"Pomočnik"</string>
    <string name="phoneTypeMms" msgid="1799747455131365989">"MMS"</string>
    <string name="eventTypeCustom" msgid="3257367158986466481">"Po meri"</string>
    <string name="eventTypeBirthday" msgid="7770026752793912283">"Rojstni dan"</string>
    <string name="eventTypeAnniversary" msgid="4684702412407916888">"Obletnica"</string>
    <string name="eventTypeOther" msgid="530671238533887997">"Drugo"</string>
    <string name="emailTypeCustom" msgid="1809435350482181786">"Po meri"</string>
    <string name="emailTypeHome" msgid="1597116303154775999">"Dom"</string>
    <string name="emailTypeWork" msgid="2020095414401882111">"Služba"</string>
    <string name="emailTypeOther" msgid="5131130857030897465">"Drugo"</string>
    <string name="emailTypeMobile" msgid="787155077375364230">"Mobilni"</string>
    <string name="postalTypeCustom" msgid="5645590470242939129">"Po meri"</string>
    <string name="postalTypeHome" msgid="7562272480949727912">"Dom"</string>
    <string name="postalTypeWork" msgid="8553425424652012826">"Služba"</string>
    <string name="postalTypeOther" msgid="7094245413678857420">"Drugo"</string>
    <string name="imTypeCustom" msgid="5653384545085765570">"Po meri"</string>
    <string name="imTypeHome" msgid="6996507981044278216">"Dom"</string>
    <string name="imTypeWork" msgid="2099668940169903123">"Služba"</string>
    <string name="imTypeOther" msgid="8068447383276219810">"Drugo"</string>
    <string name="imProtocolCustom" msgid="4437878287653764692">"Po meri"</string>
    <string name="imProtocolAim" msgid="4050198236506604378">"AIM"</string>
    <string name="imProtocolMsn" msgid="2257148557766499232">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="5373338758093392231">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="1486297589164830043">"Skype"</string>
    <string name="imProtocolQq" msgid="7254708777029006592">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="9194016024343166782">"Hangouts"</string>
    <string name="imProtocolIcq" msgid="2410325380427389521">"ICQ"</string>
    <string name="imProtocolJabber" msgid="7919269388889582015">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="4985002408136148256">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="8684458700669564172">"Služba"</string>
    <string name="orgTypeOther" msgid="5450675258408005553">"Drugo"</string>
    <string name="orgTypeCustom" msgid="1126322047677329218">"Po meri"</string>
    <string name="relationTypeCustom" msgid="282938315217441351">"Po meri"</string>
    <string name="relationTypeAssistant" msgid="4057605157116589315">"Pomočnik"</string>
    <string name="relationTypeBrother" msgid="7141662427379247820">"Brat"</string>
    <string name="relationTypeChild" msgid="9076258911292693601">"Otrok"</string>
    <string name="relationTypeDomesticPartner" msgid="7825306887697559238">"Partner"</string>
    <string name="relationTypeFather" msgid="3856225062864790596">"Oče"</string>
    <string name="relationTypeFriend" msgid="3192092625893980574">"Prijatelj"</string>
    <string name="relationTypeManager" msgid="2272860813153171857">"Vodja"</string>
    <string name="relationTypeMother" msgid="2331762740982699460">"Mati"</string>
    <string name="relationTypeParent" msgid="4177920938333039882">"Starši"</string>
    <string name="relationTypePartner" msgid="4018017075116766194">"Partner"</string>
    <string name="relationTypeReferredBy" msgid="5285082289602849400">"Predlagatelj"</string>
    <string name="relationTypeRelative" msgid="3396498519818009134">"Sorodnik"</string>
    <string name="relationTypeSister" msgid="3721676005094140671">"Sestra"</string>
    <string name="relationTypeSpouse" msgid="6916682664436031703">"Zakonski partner"</string>
    <string name="sipAddressTypeCustom" msgid="6283889809842649336">"Po meri"</string>
    <string name="sipAddressTypeHome" msgid="5918441930656878367">"Dom"</string>
    <string name="sipAddressTypeWork" msgid="7873967986701216770">"Služba"</string>
    <string name="sipAddressTypeOther" msgid="6317012577345187275">"Drugo"</string>
    <string name="quick_contacts_not_available" msgid="1262709196045052223">"Ni aplikacije za ogled tega stika."</string>
    <string name="keyguard_password_enter_pin_code" msgid="6401406801060956153">"Vnesite kodo PIN"</string>
    <string name="keyguard_password_enter_puk_code" msgid="3112256684547584093">"Vnesite kodo PUK in novo kodo PIN"</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="2825313071899938305">"Koda PUK"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="5505434724229581207">"Nova koda PIN"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="4032288032993261520"><font size="17">"Dotaknite se za vnos gesla"</font></string>
    <string name="keyguard_password_enter_password_code" msgid="2751130557661643482">"Vnesite geslo za odklepanje"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="7792964196473964340">"Vnesite PIN za odklepanje"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="8583732939138432793">"Napačna koda PIN."</string>
    <string name="keyguard_label_text" msgid="3841953694564168384">"Če želite telefon odkleniti, pritisnite meni in nato 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="2978165477085612673">"Številka za klic v sili"</string>
    <string name="lockscreen_carrier_default" msgid="6192313772955399160">"Ni signala"</string>
    <string name="lockscreen_screen_locked" msgid="7364905540516041817">"Zaslon je zaklenjen."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="7982445492532123308">"Če želite odkleniti napravo ali opraviti klic v sili, pritisnite meni."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="7434061749374801753">"Če želite odkleniti, pritisnite meni."</string>
    <string name="lockscreen_pattern_instructions" msgid="3169991838169244941">"Če želite odkleniti, narišite vzorec"</string>
    <string name="lockscreen_emergency_call" msgid="7500692654885445299">"Klic v sili"</string>
    <string name="lockscreen_return_to_call" msgid="3156883574692006382">"Nazaj na klic"</string>
    <string name="lockscreen_pattern_correct" msgid="8050630103651508582">"Pravilno."</string>
    <string name="lockscreen_pattern_wrong" msgid="2940138714468358458">"Poskusi znova"</string>
    <string name="lockscreen_password_wrong" msgid="8605355913868947490">"Poskusite znova"</string>
    <string name="lockscreen_storage_locked" msgid="634993789186443380">"Odklenite za dostop do vseh funkcij in podatkov"</string>
    <string name="faceunlock_multiple_failures" msgid="681991538434031708">"Presegli ste dovoljeno število poskusov odklepanja z obrazom"</string>
    <string name="lockscreen_missing_sim_message_short" msgid="1248431165144893792">"Ni kartice SIM"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="8596805728510570760">"V tabličnem računalniku ni kartice SIM."</string>
    <string name="lockscreen_missing_sim_message" product="tv" msgid="2582768023352171073">"V napravi Android TV ni kartice SIM."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="1408695081255172556">"V telefonu ni kartice SIM."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="8473601862688263903">"Vstavite kartico SIM."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3664999892038416334">"Ni kartice SIM ali je ni mogoče prebrati. Vstavite kartico SIM."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="3812893366715730539">"Neuporabna kartica SIM."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="4358929052509450807">"Kartica SIM je trajno onemogočena.\n Če želite dobiti drugo kartico SIM, se obrnite na ponudnika brezžičnih storitev."</string>
    <string name="lockscreen_transport_prev_description" msgid="2879469521751181478">"Prejšnja skladba"</string>
    <string name="lockscreen_transport_next_description" msgid="2931509904881099919">"Naslednja skladba"</string>
    <string name="lockscreen_transport_pause_description" msgid="6705284702135372494">"Zaustavi"</string>
    <string name="lockscreen_transport_play_description" msgid="106868788691652733">"Predvajaj"</string>
    <string name="lockscreen_transport_stop_description" msgid="1449552232598355348">"Ustavi"</string>
    <string name="lockscreen_transport_rew_description" msgid="7680106856221622779">"Previj nazaj"</string>
    <string name="lockscreen_transport_ffw_description" msgid="4763794746640196772">"Previj naprej"</string>
    <string name="emergency_calls_only" msgid="3057351206678279851">"Le klici v sili"</string>
    <string name="lockscreen_network_locked_message" msgid="2814046965899249635">"Omrežje je zaklenjeno"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="6618356415831082174">"Kartica SIM je zaklenjena s kodo PUK."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="5307979043730860995">"Preberite uporabniški priročnik ali se obrnite na oddelek za skrb za stranke."</string>
    <string name="lockscreen_sim_locked_message" msgid="3160196135801185938">"Kartica SIM je zaklenjena."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="2286497117428409709">"Odklepanje kartice SIM ..."</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6458790975898594240">"Vzorec za odklepanje ste nepravilno narisali <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat. \n\nPoskusite znova čez <xliff:g id="NUMBER_1">%2$d</xliff:g> s."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="3118353451602377380">"Geslo ste <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat vnesli napačno. \n\nZnova poskusite čez <xliff:g id="NUMBER_1">%2$d</xliff:g> s."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="2874278239714821984">"PIN ste <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat vnesli napačno. \n\nZnova poskusite čez <xliff:g id="NUMBER_1">%2$d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="3069635524964070596">"Vzorec za odklepanje ste nepravilno vnesli <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat. Po <xliff:g id="NUMBER_1">%2$d</xliff:g> neuspešnih poskusih boste pozvani, da odklenete tablični računalnik z Googlovimi podatki za prijavo.\n\nPoskusite znova čez <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tv" msgid="6399092175942158529">"Vzorec za odklepanje ste nepravilno narisali <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat. Po <xliff:g id="NUMBER_1">%2$d</xliff:g> neuspešnih poskusih boste pozvani, da odklenete napravo Android TV z Googlovimi podatki za prijavo.\n\nPoskusite znova čez <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="5691623136957148335">"Vzorec za odklepanje ste nepravilno vnesli <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat. Po <xliff:g id="NUMBER_1">%2$d</xliff:g> neuspešnih poskusih boste pozvani, da odklenete telefon z Googlovimi podatki za prijavo.\n\nPoskusite znova čez <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="7914445759242151426">"Tablični računalnik ste poskusili <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat nepravilno odkleniti. Če poskusite še <xliff:g id="NUMBER_1">%2$d</xliff:g>-krat in ne uspete, bo ponastavljen na privzete tovarniške nastavitve, vsi uporabniški podatki pa bodo izbrisani."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tv" msgid="4275591249631864248">"Napravo Android TV ste neuspešno poskusili odkleniti <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat. Če poskusite še <xliff:g id="NUMBER_1">%2$d</xliff:g>-krat in ne uspete, bo naprava Android TV ponastavljena na privzete tovarniške nastavitve, vsi uporabniški podatki pa bodo izgubljeni."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="1166532464798446579">"Telefon ste poskusili <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat nepravilno odkleniti. Če poskusite še <xliff:g id="NUMBER_1">%2$d</xliff:g>-krat in ne uspete, bo ponastavljen na privzete tovarniške nastavitve, vsi uporabniški podatki pa bodo izgubljeni."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="8682445539263683414">"Tablični računalnik ste poskusili <xliff:g id="NUMBER">%d</xliff:g>-krat nepravilno odkleniti, zato bo zdaj ponastavljen na privzete tovarniške nastavitve."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tv" msgid="2205435033340091883">"Napravo Android TV ste neuspešno poskusili odkleniti <xliff:g id="NUMBER">%d</xliff:g>-krat. Naprava Android TV bo zdaj ponastavljena na privzete tovarniške nastavitve."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="2203704707679895487">"Telefon ste poskusili <xliff:g id="NUMBER">%d</xliff:g>-krat nepravilno odkleniti, zato bo ponastavljen na privzete tovarniške nastavitve."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6807200118164539589">"Poskusite znova čez <xliff:g id="NUMBER">%d</xliff:g> sekund."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="8362442730606839031">"Ali ste pozabili vzorec?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="9218940117797602518">"Odklepanje računa"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="3775904917743034195">"Preveč poskusov vzorca"</string>
    <string name="lockscreen_glogin_instructions" msgid="4695162942525531700">"Če želite odkleniti telefon, se prijavite z Google Računom."</string>
    <string name="lockscreen_glogin_username_hint" msgid="6916101478673157045">"Uporabniško ime (e-pošta)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="3031027901286812848">"Geslo"</string>
    <string name="lockscreen_glogin_submit_button" msgid="3590556636347843733">"Prijava"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="4369219936865697679">"Neveljavno uporabniško ime ali geslo."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1683405808525090649">"Ali ste pozabili uporabniško ime ali geslo?\nObiščite "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="lockscreen_glogin_checking_password" msgid="2607271802803381645">"Preverjanje ..."</string>
    <string name="lockscreen_unlock_label" msgid="4648257878373307582">"Odkleni"</string>
    <string name="lockscreen_sound_on_label" msgid="1660281470535492430">"Vklopi zvok"</string>
    <string name="lockscreen_sound_off_label" msgid="2331496559245450053">"Izklopi zvok"</string>
    <string name="lockscreen_access_pattern_start" msgid="3778502525702613399">"Vzorec se je začel"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="7493849102641167049">"Vzorec je izbrisan"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6746676335293144163">"Celica je dodana"</string>
    <string name="lockscreen_access_pattern_cell_added_verbose" msgid="2931364927622563465">"Dodana <xliff:g id="CELL_INDEX">%1$s</xliff:g>. celica"</string>
    <string name="lockscreen_access_pattern_detected" msgid="3931150554035194012">"Vzorec je končan"</string>
    <string name="lockscreen_access_pattern_area" msgid="1288780416685002841">"Območje vzorca."</string>
    <string name="keyguard_accessibility_widget_changed" msgid="7298011259508200234">"%1$s. Pripomoček %2$d za %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8245795023551343672">"Dodajanje pripomočka."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="544239307077644480">"Prazno"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="7768634718706488951">"Območje odklepanja razširjeno."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="4729922043778400434">"Območje odklepanja strnjeno."</string>
    <string name="keyguard_accessibility_widget" msgid="6776892679715699875">"Pripomoček <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1466067610235696600">"Izbirnik uporabnika"</string>
    <string name="keyguard_accessibility_status" msgid="6792745049712397237">"Stanje"</string>
    <string name="keyguard_accessibility_camera" msgid="7862557559464986528">"Fotoaparat"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="2267379779900620614">"Kontrolniki predstavnosti"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="7066213328912939191">"Prerazporejanje pripomočkov začeto."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="1083806817600593490">"Prerazporejanje pripomočkov končano."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="1509738950119878705">"Pripomoček <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> izbrisan."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="4215280881346033434">"Razširitev območja odklepanja."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2968195219692413046">"Odklepanje s podrsanjem."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="8669128146589233293">"Odklepanje z vzorcem."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="632407612842329815">"Odklepanje z obrazom."</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="4020864007967340068">"Odklepanje s kodo PIN."</string>
    <string name="keyguard_accessibility_sim_pin_unlock" msgid="4895939120871890557">"Odklepanje kartice SIM s kodo PIN"</string>
    <string name="keyguard_accessibility_sim_puk_unlock" msgid="3459003464041899101">"Odklepanje kartice SIM s kodo PUK"</string>
    <string name="keyguard_accessibility_password_unlock" msgid="6130186108581153265">"Odklepanje z geslom."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="1419570880512350689">"Območje vzorca."</string>
    <string name="keyguard_accessibility_slide_area" msgid="4331399051142520176">"Območje podrsanja."</string>
    <string name="password_keyboard_label_symbol_key" msgid="2716255580853511949">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="5294837425652726684">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="8528261816395508841">"ALT"</string>
    <string name="granularity_label_character" msgid="8903387663153706317">"znak"</string>
    <string name="granularity_label_word" msgid="3686589158760620518">"beseda"</string>
    <string name="granularity_label_link" msgid="9007852307112046526">"povezava"</string>
    <string name="granularity_label_line" msgid="376204904280620221">"vrstica"</string>
    <string name="factorytest_failed" msgid="3190979160945298006">"Tovarniški preskus ni uspel"</string>
    <string name="factorytest_not_system" msgid="5658160199925519869">"Dejanje FACTORY_TEST je podprto le za pakete, nameščene v razdelku /system/app."</string>
    <string name="factorytest_no_action" msgid="339252838115675515">"Ni bilo najdenega paketa, ki omogoča dejanje FACTORY_TEST."</string>
    <string name="factorytest_reboot" msgid="2050147445567257365">"Znova zaženi"</string>
    <string name="js_dialog_title" msgid="7464775045615023241">"Na strani na »<xliff:g id="TITLE">%s</xliff:g>« piše:"</string>
    <string name="js_dialog_title_default" msgid="3769524569903332476">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="7012587995876771246">"Potrditev krmarjenja"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="4274257182303565509">"Zapusti to stran"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="3873765747622415310">"Ostani na tej strani"</string>
    <string name="js_dialog_before_unload" msgid="7213364985774778744">"<xliff:g id="MESSAGE">%s</xliff:g>\n\nAli res želite zapustiti to stran?"</string>
    <string name="save_password_label" msgid="9161712335355510035">"Potrdi"</string>
    <string name="double_tap_toast" msgid="7065519579174882778">"Nasvet: Tapnite dvakrat, če želite povečati ali pomanjšati."</string>
    <string name="autofill_this_form" msgid="3187132440451621492">"Samoizp."</string>
    <string name="setup_autofill" msgid="5431369130866618567">"Nastavi samoizp."</string>
    <string name="autofill_window_title" msgid="4379134104008111961">"Samodejno izpolnjevanje s storitvijo <xliff:g id="SERVICENAME">%1$s</xliff:g>"</string>
    <string name="autofill_address_name_separator" msgid="8190155636149596125">" "</string>
    <string name="autofill_address_summary_name_format" msgid="3402882515222673691">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="760522655085707045">", "</string>
    <string name="autofill_address_summary_format" msgid="8417010069362125194">"$1$2$3"</string>
    <string name="autofill_province" msgid="3676846437741893159">"Provinca"</string>
    <string name="autofill_postal_code" msgid="7034789388968295591">"Poštna številka"</string>
    <string name="autofill_state" msgid="3341725337190434069">"Zvezna država"</string>
    <string name="autofill_zip_code" msgid="1315503730274962450">"Poštna številka"</string>
    <string name="autofill_county" msgid="7781382735643492173">"Okrožje"</string>
    <string name="autofill_island" msgid="5367139008536593734">"Otok"</string>
    <string name="autofill_district" msgid="6428712062213557327">"Okraj"</string>
    <string name="autofill_department" msgid="9047276226873531529">"Departma"</string>
    <string name="autofill_prefecture" msgid="7267397763720241872">"Prefektura"</string>
    <string name="autofill_parish" msgid="6847960518334530198">"Župnija"</string>
    <string name="autofill_area" msgid="8289022370678448983">"Območje"</string>
    <string name="autofill_emirate" msgid="2544082046790551168">"Emirat"</string>
    <string name="permlab_readHistoryBookmarks" msgid="9102293913842539697">"branje spletnih zaznamkov in zgodovine"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="2323799501008967852">"Aplikaciji omogoča, da prebere zgodovino vseh URL-jev, ki jih je obiskal brskalnik, in vse zaznamke brskalnika. Opomba: Tega dovoljenja ne morejo uveljavljati drugi brskalniki ali aplikacije, s katerimi je mogoče brskati po spletu."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="6090259925187986937">"zapisovanje spletnih zaznamkov in zgodovine"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="573341025292489065">"Aplikaciji omogoča spreminjanje zgodovine ali zaznamkov brskalnika v tabličnem računalniku. S tem lahko aplikacija izbriše ali spremeni podatke v brskalniku. Opomba: Tega dovoljenja ne morejo uveljavljati drugi brskalniki ali aplikacije, s katerimi je mogoče brskati po spletu."</string>
    <string name="permdesc_writeHistoryBookmarks" product="tv" msgid="88642768580408561">"Aplikaciji dovoljuje spreminjanje zgodovine ali zaznamkov brskalnika v napravi Android TV. S tem lahko aplikacija briše ali spreminja podatke brskalnika. Opomba: tega dovoljenja morda ne morejo uveljavljati drugi brskalniki ali aplikacije, s katerimi je mogoče brskati po spletu."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="2245203087160913652">"Aplikaciji omogoča spreminjanje zgodovine ali zaznamkov brskalnika v telefonu. S tem lahko aplikacija izbriše ali spremeni podatke v brskalniku. Opomba: Tega dovoljenja ne morejo uveljavljati drugi brskalniki ali aplikacije, s katerimi je mogoče brskati po spletu."</string>
    <string name="permlab_setAlarm" msgid="1158001610254173567">"nastavitev alarma"</string>
    <string name="permdesc_setAlarm" msgid="2185033720060109640">"Aplikaciji omogoča nastavitev alarma v nameščeni aplikaciji budilke. Nekatere aplikacije budilke morda nimajo te funkcije."</string>
    <string name="permlab_addVoicemail" msgid="4770245808840814471">"dodajanje odzivnika"</string>
    <string name="permdesc_addVoicemail" msgid="5470312139820074324">"Aplikaciji omogoča dodajanje sporočil prejetim sporočilom odzivnika."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="8605631647492879449">"Spreminjanje dovoljenj za geolokacijo brskalnika"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="5817346421222227772">"Aplikaciji omogoča spreminjanje geolokacijskih dovoljenj v brskalniku. Zlonamerne aplikacije lahko to izkoristijo za pošiljanje podatkov o lokaciji poljubnim spletnim mestom."</string>
    <string name="save_password_message" msgid="2146409467245462965">"Ali želite, da si brskalnik zapomni to geslo?"</string>
    <string name="save_password_notnow" msgid="2878327088951240061">"Ne zdaj"</string>
    <string name="save_password_remember" msgid="6490888932657708341">"Zapomni si"</string>
    <string name="save_password_never" msgid="6776808375903410659">"Nikoli"</string>
    <string name="open_permission_deny" msgid="5136793905306987251">"Nimate dovoljenja za odpiranje te strani."</string>
    <string name="text_copied" msgid="2531420577879738860">"Besedilo, kopirano v odložišče."</string>
    <string name="copied" msgid="4675902854553014676">"Kopirano"</string>
    <string name="more_item_label" msgid="7419249600215749115">"Več"</string>
    <string name="prepend_shortcut_label" msgid="1743716737502867951">"Meni+"</string>
    <string name="menu_meta_shortcut_label" msgid="1623390163674762478">"Meta +"</string>
    <string name="menu_ctrl_shortcut_label" msgid="131911133027196485">"Ctrl +"</string>
    <string name="menu_alt_shortcut_label" msgid="343761069945250991">"Alt +"</string>
    <string name="menu_shift_shortcut_label" msgid="5443936876111232346">"Shift +"</string>
    <string name="menu_sym_shortcut_label" msgid="4037566049061218776">"Sym +"</string>
    <string name="menu_function_shortcut_label" msgid="2367112760987662566">"Fn +"</string>
    <string name="menu_space_shortcut_label" msgid="5949311515646872071">"presledek"</string>
    <string name="menu_enter_shortcut_label" msgid="6709499510082897320">"vnesi"</string>
    <string name="menu_delete_shortcut_label" msgid="4365787714477739080">"izbriši"</string>
    <string name="search_go" msgid="2141477624421347086">"Iskanje"</string>
    <string name="search_hint" msgid="455364685740251925">"Iskanje ..."</string>
    <string name="searchview_description_search" msgid="1045552007537359343">"Iskanje"</string>
    <string name="searchview_description_query" msgid="7430242366971716338">"Iskalna poizvedba"</string>
    <string name="searchview_description_clear" msgid="1989371719192982900">"Izbris poizvedbe"</string>
    <string name="searchview_description_submit" msgid="6771060386117334686">"Pošlji poizvedbo"</string>
    <string name="searchview_description_voice" msgid="42360159504884679">"Glasovno iskanje"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="5095399706284943314">"Vklop raziskovanja z dotikom?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="1037295476738940824">"Storitev <xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> želi omogočiti raziskovanje z dotikom. Ko je raziskovanje z dotikom vklopljeno, lahko slišite ali vidite opise tega, kar je pod vašim prstom, ali izvajate poteze za interakcijo s tabličnim računalnikom."</string>
    <string name="enable_explore_by_touch_warning_message" product="default" msgid="4312979647356179250">"Storitev <xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> želi omogočiti raziskovanje z dotikom. Ko je raziskovanje z dotikom vklopljeno, lahko slišite ali vidite opise tega, kar je pod vašim prstom, ali izvajate poteze za interakcijo s telefonom."</string>
    <string name="oneMonthDurationPast" msgid="4538030857114635777">"Pred 1 mesecem"</string>
    <string name="beforeOneMonthDurationPast" msgid="8315149541372065392">"Pred več kot 1 mesecem"</string>
    <plurals name="last_num_days" formatted="false" msgid="687443109145393632">
      <item quantity="one">Zadnji <xliff:g id="COUNT_1">%d</xliff:g> dan</item>
      <item quantity="two">Zadnja <xliff:g id="COUNT_1">%d</xliff:g> dneva</item>
      <item quantity="few">Zadnje <xliff:g id="COUNT_1">%d</xliff:g> dni</item>
      <item quantity="other">Zadnjih <xliff:g id="COUNT_1">%d</xliff:g> dni</item>
    </plurals>
    <string name="last_month" msgid="1528906781083518683">"Pretekli mesec"</string>
    <string name="older" msgid="1645159827884647400">"Starejše"</string>
    <string name="preposition_for_date" msgid="2780767868832729599">"<xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="4336835286453822053">"ob <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="3149809685340130039">"leta <xliff:g id="YEAR">%s</xliff:g>"</string>
    <string name="day" msgid="8394717255950176156">"dan"</string>
    <string name="days" msgid="4570879797423034973">"dni"</string>
    <string name="hour" msgid="7796325297097314653">"ura"</string>
    <string name="hours" msgid="8517014849629200683">"ur"</string>
    <string name="minute" msgid="8369209540986467610">"min"</string>
    <string name="minutes" msgid="3456532942641808971">"minut"</string>
    <string name="second" msgid="9210875257112211713">"s"</string>
    <string name="seconds" msgid="2175052687727971048">"sekund"</string>
    <string name="week" msgid="907127093960923779">"teden"</string>
    <string name="weeks" msgid="3516247214269821391">"tednov"</string>
    <string name="year" msgid="5182610307741238982">"leto"</string>
    <string name="years" msgid="5797714729103773425">"let"</string>
    <string name="now_string_shortest" msgid="3684914126941650330">"zdaj"</string>
    <plurals name="duration_minutes_shortest" formatted="false" msgid="7519574894537185135">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g>m</item>
      <item quantity="two"><xliff:g id="COUNT_1">%d</xliff:g>m</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>m</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>m</item>
    </plurals>
    <plurals name="duration_hours_shortest" formatted="false" msgid="2838655994500499651">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="two"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
    </plurals>
    <plurals name="duration_days_shortest" formatted="false" msgid="3686058472983158496">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="two"><xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>d</item>
    </plurals>
    <plurals name="duration_years_shortest" formatted="false" msgid="8299112348723640338">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g>l</item>
      <item quantity="two"><xliff:g id="COUNT_1">%d</xliff:g>l</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>l</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>l</item>
    </plurals>
    <plurals name="duration_minutes_shortest_future" formatted="false" msgid="849196137176399440">
      <item quantity="one">čez <xliff:g id="COUNT_1">%d</xliff:g>m</item>
      <item quantity="two">čez <xliff:g id="COUNT_1">%d</xliff:g>m</item>
      <item quantity="few">čez <xliff:g id="COUNT_1">%d</xliff:g>m</item>
      <item quantity="other">čez <xliff:g id="COUNT_1">%d</xliff:g>m</item>
    </plurals>
    <plurals name="duration_hours_shortest_future" formatted="false" msgid="5386373597343170388">
      <item quantity="one">čez <xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="two">čez <xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="few">čez <xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="other">čez <xliff:g id="COUNT_1">%d</xliff:g>h</item>
    </plurals>
    <plurals name="duration_days_shortest_future" formatted="false" msgid="814754627092787227">
      <item quantity="one">čez <xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="two">čez <xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="few">čez <xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="other">čez <xliff:g id="COUNT_1">%d</xliff:g>d</item>
    </plurals>
    <plurals name="duration_years_shortest_future" formatted="false" msgid="7683731800140202145">
      <item quantity="one">čez <xliff:g id="COUNT_1">%d</xliff:g> l</item>
      <item quantity="two">čez <xliff:g id="COUNT_1">%d</xliff:g> l</item>
      <item quantity="few">čez <xliff:g id="COUNT_1">%d</xliff:g> l</item>
      <item quantity="other">čez <xliff:g id="COUNT_1">%d</xliff:g> l</item>
    </plurals>
    <plurals name="duration_minutes_relative" formatted="false" msgid="6569851308583028344">
      <item quantity="one">pred <xliff:g id="COUNT_1">%d</xliff:g> minuto</item>
      <item quantity="two">pred <xliff:g id="COUNT_1">%d</xliff:g> minutama</item>
      <item quantity="few">pred <xliff:g id="COUNT_1">%d</xliff:g> minutami</item>
      <item quantity="other">pred <xliff:g id="COUNT_1">%d</xliff:g> minutami</item>
    </plurals>
    <plurals name="duration_hours_relative" formatted="false" msgid="420434788589102019">
      <item quantity="one">pred <xliff:g id="COUNT_1">%d</xliff:g> h</item>
      <item quantity="two">pred <xliff:g id="COUNT_1">%d</xliff:g> h</item>
      <item quantity="few">pred <xliff:g id="COUNT_1">%d</xliff:g> h</item>
      <item quantity="other">pred <xliff:g id="COUNT_1">%d</xliff:g> h</item>
    </plurals>
    <plurals name="duration_days_relative" formatted="false" msgid="6056425878237482431">
      <item quantity="one">pred <xliff:g id="COUNT_1">%d</xliff:g> dnevom</item>
      <item quantity="two">pred <xliff:g id="COUNT_1">%d</xliff:g> dnevoma</item>
      <item quantity="few">pred <xliff:g id="COUNT_1">%d</xliff:g> dnevi</item>
      <item quantity="other">pred <xliff:g id="COUNT_1">%d</xliff:g> dnevi</item>
    </plurals>
    <plurals name="duration_years_relative" formatted="false" msgid="2179998228861172159">
      <item quantity="one">pred <xliff:g id="COUNT_1">%d</xliff:g> letom</item>
      <item quantity="two">pred <xliff:g id="COUNT_1">%d</xliff:g> letoma</item>
      <item quantity="few">pred <xliff:g id="COUNT_1">%d</xliff:g> leti</item>
      <item quantity="other">pred <xliff:g id="COUNT_1">%d</xliff:g> leti</item>
    </plurals>
    <plurals name="duration_minutes_relative_future" formatted="false" msgid="5759885720917567723">
      <item quantity="one">čez <xliff:g id="COUNT_1">%d</xliff:g> minuto</item>
      <item quantity="two">čez <xliff:g id="COUNT_1">%d</xliff:g> minuti</item>
      <item quantity="few">čez <xliff:g id="COUNT_1">%d</xliff:g> minute</item>
      <item quantity="other">čez <xliff:g id="COUNT_1">%d</xliff:g> minut</item>
    </plurals>
    <plurals name="duration_hours_relative_future" formatted="false" msgid="8963511608507707959">
      <item quantity="one">čez <xliff:g id="COUNT_1">%d</xliff:g> uro</item>
      <item quantity="two">čez <xliff:g id="COUNT_1">%d</xliff:g> uri</item>
      <item quantity="few">čez <xliff:g id="COUNT_1">%d</xliff:g> ure</item>
      <item quantity="other">čez <xliff:g id="COUNT_1">%d</xliff:g> ur</item>
    </plurals>
    <plurals name="duration_days_relative_future" formatted="false" msgid="1964709470979250702">
      <item quantity="one">čez <xliff:g id="COUNT_1">%d</xliff:g> dan</item>
      <item quantity="two">čez <xliff:g id="COUNT_1">%d</xliff:g> dneva</item>
      <item quantity="few">čez <xliff:g id="COUNT_1">%d</xliff:g> dni</item>
      <item quantity="other">čez <xliff:g id="COUNT_1">%d</xliff:g> dni</item>
    </plurals>
    <plurals name="duration_years_relative_future" formatted="false" msgid="3985129025134896371">
      <item quantity="one">čez <xliff:g id="COUNT_1">%d</xliff:g> leto</item>
      <item quantity="two">čez <xliff:g id="COUNT_1">%d</xliff:g> leti</item>
      <item quantity="few">čez <xliff:g id="COUNT_1">%d</xliff:g> leta</item>
      <item quantity="other">čez <xliff:g id="COUNT_1">%d</xliff:g> let</item>
    </plurals>
    <string name="VideoView_error_title" msgid="5750686717225068016">"Težava z videoposnetkom"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3782449246085134720">"Ta videoposnetek ni veljaven za pretakanje v to napravo."</string>
    <string name="VideoView_error_text_unknown" msgid="7658683339707607138">"Tega videoposnetka ni mogoče predvajati."</string>
    <string name="VideoView_error_button" msgid="5138809446603764272">"V redu"</string>
    <string name="relative_time" msgid="8572030016028033243">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="8365974533050605886">"opoldne"</string>
    <string name="Noon" msgid="6902418443846838189">"Opoldne"</string>
    <string name="midnight" msgid="3646671134282785114">"polnoč"</string>
    <string name="Midnight" msgid="8176019203622191377">"Polnoč"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="8689459651807876423">"<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="2302144714803345056">"<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="1532369154488982046">"Izberi vse"</string>
    <string name="cut" msgid="2561199725874745819">"Izreži"</string>
    <string name="copy" msgid="5472512047143665218">"Kopiraj"</string>
    <string name="failed_to_copy_to_clipboard" msgid="725919885138539875">"Kopiranje v odložišče ni uspelo"</string>
    <string name="paste" msgid="461843306215520225">"Prilepi"</string>
    <string name="paste_as_plain_text" msgid="7664800665823182587">"Prilepi kot navadno besedilo"</string>
    <string name="replace" msgid="7842675434546657444">"Zamenjaj •"</string>
    <string name="delete" msgid="1514113991712129054">"Izbriši"</string>
    <string name="copyUrl" msgid="6229645005987260230">"Kopiraj URL"</string>
    <string name="selectTextMode" msgid="3225108910999318778">"Izbira besedila"</string>
    <string name="undo" msgid="3175318090002654673">"Razveljavi"</string>
    <string name="redo" msgid="7231448494008532233">"Uveljavi"</string>
    <string name="autofill" msgid="511224882647795296">"Samodejno izpolnjevanje"</string>
    <string name="textSelectionCABTitle" msgid="5151441579532476940">"Izbrano besedilo"</string>
    <string name="addToDictionary" msgid="8041821113480950096">"Dodaj v slovar"</string>
    <string name="deleteText" msgid="4200807474529938112">"Izbriši"</string>
    <string name="inputMethod" msgid="1784759500516314751">"Način vnosa"</string>
    <string name="editTextMenuTitle" msgid="857666911134482176">"Besedilna dejanja"</string>
    <string name="low_internal_storage_view_title" msgid="9024241779284783414">"Prostor za shranjevanje bo pošel"</string>
    <string name="low_internal_storage_view_text" msgid="8172166728369697835">"Nekatere sistemske funkcije morda ne delujejo"</string>
    <string name="low_internal_storage_view_text_no_boot" msgid="7368968163411251788">"V shrambi ni dovolj prostora za sistem. Sprostite 250 MB prostora in znova zaženite napravo."</string>
    <string name="app_running_notification_title" msgid="8985999749231486569">"<xliff:g id="APP_NAME">%1$s</xliff:g> se izvaja"</string>
    <string name="app_running_notification_text" msgid="5120815883400228566">"Dotaknite se, če želite izvedeti več ali ustaviti aplikacijo."</string>
    <string name="ok" msgid="2646370155170753815">"V redu"</string>
    <string name="cancel" msgid="6908697720451760115">"Prekliči"</string>
    <string name="yes" msgid="9069828999585032361">"V redu"</string>
    <string name="no" msgid="5122037903299899715">"Prekliči"</string>
    <string name="dialog_alert_title" msgid="651856561974090712">"Pozor"</string>
    <string name="loading" msgid="3138021523725055037">"Nalaganje …"</string>
    <string name="capital_on" msgid="2770685323900821829">"VKLOPLJENO"</string>
    <string name="capital_off" msgid="7443704171014626777">"IZKLOPLJENO"</string>
    <string name="checked" msgid="9179896827054513119">"potrjeno"</string>
    <string name="not_checked" msgid="7972320087569023342">"ni potrjeno"</string>
    <string name="whichApplication" msgid="5432266899591255759">"Dokončanje dejanja z"</string>
    <string name="whichApplicationNamed" msgid="6969946041713975681">"Dokončanje dejanja z aplikacijo %1$s"</string>
    <string name="whichApplicationLabel" msgid="7852182961472531728">"Izvedba dejanja"</string>
    <string name="whichViewApplication" msgid="5733194231473132945">"Odpiranje z aplikacijo"</string>
    <string name="whichViewApplicationNamed" msgid="415164730629690105">"Odpiranje z aplikacijo %1$s"</string>
    <string name="whichViewApplicationLabel" msgid="7367556735684742409">"Odpiranje"</string>
    <string name="whichOpenHostLinksWith" msgid="7645631470199397485">"Odpiranje povezav <xliff:g id="HOST">%1$s</xliff:g> z"</string>
    <string name="whichOpenLinksWith" msgid="1120936181362907258">"Odpiranje povezav z"</string>
    <string name="whichOpenLinksWithApp" msgid="6917864367861910086">"Odpiranje povezav z aplikacijo <xliff:g id="APPLICATION">%1$s</xliff:g>"</string>
    <string name="whichOpenHostLinksWithApp" msgid="2401668560768463004">"Odpiranje povezav <xliff:g id="HOST">%1$s</xliff:g> z aplikacijo <xliff:g id="APPLICATION">%2$s</xliff:g>"</string>
    <string name="whichGiveAccessToApplicationLabel" msgid="7805857277166106236">"Omogoči dostop"</string>
    <string name="whichEditApplication" msgid="6191568491456092812">"Urejanje z aplikacijo"</string>
    <string name="whichEditApplicationNamed" msgid="8096494987978521514">"Urejanje z aplikacijo %1$s"</string>
    <string name="whichEditApplicationLabel" msgid="1463288652070140285">"Urejanje"</string>
    <string name="whichSendApplication" msgid="4143847974460792029">"Deljenje z drugimi"</string>
    <string name="whichSendApplicationNamed" msgid="4470386782693183461">"Skupna raba z aplikacijo %1$s"</string>
    <string name="whichSendApplicationLabel" msgid="7467813004769188515">"Skupna raba"</string>
    <string name="whichSendToApplication" msgid="77101541959464018">"Pošiljanje z aplikacijo"</string>
    <string name="whichSendToApplicationNamed" msgid="3385686512014670003">"Pošiljanje z aplikacijo %1$s"</string>
    <string name="whichSendToApplicationLabel" msgid="3543240188816513303">"Pošiljanje"</string>
    <string name="whichHomeApplication" msgid="8276350727038396616">"Izbira aplikacije na začetnem zaslonu"</string>
    <string name="whichHomeApplicationNamed" msgid="5855990024847433794">"Uporaba aplikacije %1$s na začetnem zaslonu"</string>
    <string name="whichHomeApplicationLabel" msgid="8907334282202933959">"Snemanje slike"</string>
    <string name="whichImageCaptureApplication" msgid="2737413019463215284">"Snemanje slike z aplikacijo"</string>
    <string name="whichImageCaptureApplicationNamed" msgid="8820702441847612202">"Snemanje slike z aplikacijo %1$s"</string>
    <string name="whichImageCaptureApplicationLabel" msgid="6505433734824988277">"Snemanje slike"</string>
    <string name="alwaysUse" msgid="3153558199076112903">"Privzeta uporaba za to dejanje."</string>
    <string name="use_a_different_app" msgid="4987790276170972776">"Uporaba druge aplikacije"</string>
    <string name="clearDefaultHintMsg" msgid="1325866337702524936">"Izbrišite privzet aplikacijo v sistemskih nastavitvah &gt; Aplikacije &gt; Preneseno."</string>
    <string name="chooseActivity" msgid="8563390197659779956">"Izberite dejanje"</string>
    <string name="chooseUsbActivity" msgid="2096269989990986612">"Izberite aplikacijo za napravo USB"</string>
    <string name="noApplications" msgid="1186909265235544019">"Tega dejanja ne more izvesti nobena aplikacija."</string>
    <string name="aerr_application" msgid="4090916809370389109">"Aplikacija <xliff:g id="APPLICATION">%1$s</xliff:g> se je ustavila"</string>
    <string name="aerr_process" msgid="4268018696970966407">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> se je ustavil"</string>
    <string name="aerr_application_repeated" msgid="7804378743218496566">"Aplikacija <xliff:g id="APPLICATION">%1$s</xliff:g> se stalno ustavlja"</string>
    <string name="aerr_process_repeated" msgid="1153152413537954974">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> se stalno ustavlja"</string>
    <string name="aerr_restart" msgid="2789618625210505419">"Znova odpri aplikacijo"</string>
    <string name="aerr_report" msgid="3095644466849299308">"Pošlji povratne informacije"</string>
    <string name="aerr_close" msgid="3398336821267021852">"Zapri"</string>
    <string name="aerr_mute" msgid="2304972923480211376">"Prezri do vnovičnega zagona naprave"</string>
    <string name="aerr_wait" msgid="3198677780474548217">"Počakajte"</string>
    <string name="aerr_close_app" msgid="8318883106083050970">"Zapri aplikacijo"</string>
    <string name="anr_title" msgid="7290329487067300120"></string>
    <string name="anr_activity_application" msgid="8121716632960340680">"Aplikacija <xliff:g id="APPLICATION">%2$s</xliff:g> se ne odziva"</string>
    <string name="anr_activity_process" msgid="3477362583767128667">"Dejavnost <xliff:g id="ACTIVITY">%1$s</xliff:g> se ne odziva"</string>
    <string name="anr_application_process" msgid="4978772139461676184">"Aplikacija <xliff:g id="APPLICATION">%1$s</xliff:g> se ne odziva"</string>
    <string name="anr_process" msgid="1664277165911816067">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> se ne odziva"</string>
    <string name="force_close" msgid="9035203496368973803">"V redu"</string>
    <string name="report" msgid="2149194372340349521">"Poročaj"</string>
    <string name="wait" msgid="7765985809494033348">"Čakaj"</string>
    <string name="webpage_unresponsive" msgid="7850879412195273433">"Stran se ne odziva.\n \nAli jo želite zapreti?"</string>
    <string name="launch_warning_title" msgid="6725456009564953595">"Aplikacija preusmerjena"</string>
    <string name="launch_warning_replace" msgid="3073392976283203402">"<xliff:g id="APP_NAME">%1$s</xliff:g> se izvaja."</string>
    <string name="launch_warning_original" msgid="3332206576800169626">"Prvotno je bila zagnana aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="screen_compat_mode_scale" msgid="8627359598437527726">"Lestvica"</string>
    <string name="screen_compat_mode_show" msgid="5080361367584709857">"Vedno pokaži"</string>
    <string name="screen_compat_mode_hint" msgid="4032272159093750908">"Znova omogočite to v sistemskih nastavitvah &gt; Aplikacije &gt; Preneseno."</string>
    <string name="unsupported_display_size_message" msgid="7265211375269394699">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> ne podpira trenutne nastavitve velikosti zaslona, kar lahko vodi v nepričakovano delovanje."</string>
    <string name="unsupported_display_size_show" msgid="980129850974919375">"Vedno pokaži"</string>
    <string name="unsupported_compile_sdk_message" msgid="7326293500707890537">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> je bila ustvarjena za nezdružljivo različico operacijskega sistema Android, kar lahko vodi v nepričakovano delovanje. Morda je na voljo posodobljena različica aplikacije."</string>
    <string name="unsupported_compile_sdk_show" msgid="1601210057960312248">"Vedno pokaži"</string>
    <string name="unsupported_compile_sdk_check_update" msgid="1103639989147664456">"Preveri, ali je na voljo posodobitev"</string>
    <string name="smv_application" msgid="3775183542777792638">"Aplikacija <xliff:g id="APPLICATION">%1$s</xliff:g> (proces <xliff:g id="PROCESS">%2$s</xliff:g>) krši svoj samouveljavljiv pravilnik o strogem načinu."</string>
    <string name="smv_process" msgid="1398801497130695446">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> krši svoj samoizvedljivi pravilnik o strogem načinu."</string>
    <string name="android_upgrading_title" product="default" msgid="7279077384220829683">"Telefon se posodablja …"</string>
    <string name="android_upgrading_title" product="tablet" msgid="4268417249079938805">"Tablični računalnik se posodablja …"</string>
    <string name="android_upgrading_title" product="device" msgid="6774767702998149762">"Naprava se posodablja …"</string>
    <string name="android_start_title" product="default" msgid="4036708252778757652">"Telefon se zaganja …"</string>
    <string name="android_start_title" product="automotive" msgid="7917984412828168079">"Android se zaganja …"</string>
    <string name="android_start_title" product="tablet" msgid="4429767260263190344">"Tablični računalnik se zaganja …"</string>
    <string name="android_start_title" product="device" msgid="6967413819673299309">"Naprava se zaganja …"</string>
    <string name="android_upgrading_fstrim" msgid="3259087575528515329">"Optimiziranje shrambe."</string>
    <string name="android_upgrading_notification_title" product="default" msgid="3509927005342279257">"Zaključevanje posodobitve sistema …"</string>
    <string name="app_upgrading_toast" msgid="1016267296049455585">"<xliff:g id="APPLICATION">%1$s</xliff:g> se nadgrajuje …"</string>
    <string name="android_upgrading_apk" msgid="1339564803894466737">"Optimiranje aplikacije <xliff:g id="NUMBER_0">%1$d</xliff:g> od <xliff:g id="NUMBER_1">%2$d</xliff:g>."</string>
    <string name="android_preparing_apk" msgid="589736917792300956">"Pripravljanje aplikacije <xliff:g id="APPNAME">%1$s</xliff:g>."</string>
    <string name="android_upgrading_starting_apps" msgid="6206161195076057075">"Zagon aplikacij."</string>
    <string name="android_upgrading_complete" msgid="409800058018374746">"Dokončevanje zagona."</string>
    <string name="heavy_weight_notification" msgid="8382784283600329576">"<xliff:g id="APP">%1$s</xliff:g> se izvaja"</string>
    <string name="heavy_weight_notification_detail" msgid="6802247239468404078">"Dotaknite se za vrnitev v igro"</string>
    <string name="heavy_weight_switcher_title" msgid="3861984210040100886">"Izberite igro"</string>
    <string name="heavy_weight_switcher_text" msgid="6814316627367160126">"Za večjo učinkovitost delovanja je lahko hkrati odprta samo ena od teh iger."</string>
    <string name="old_app_action" msgid="725331621042848590">"Nazaj v aplikacijo <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_action" msgid="547772182913269801">"Odpri <xliff:g id="NEW_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="1958903080400806644">"Aplikacija <xliff:g id="OLD_APP">%1$s</xliff:g> se bo zaprla brez shranjevanja"</string>
    <string name="dump_heap_notification" msgid="5316644945404825032">"Proces <xliff:g id="PROC">%1$s</xliff:g> je presegel omejitev pomnilnika"</string>
    <string name="dump_heap_ready_notification" msgid="2302452262927390268">"Izvoz kopice procesa <xliff:g id="PROC">%1$s</xliff:g> je pripravljen"</string>
    <string name="dump_heap_notification_detail" msgid="8431586843001054050">"Izvoz kopice je zbran. Dotaknite se za deljenje z drugimi."</string>
    <string name="dump_heap_title" msgid="4367128917229233901">"Deljenje izvoza kopice z drugimi?"</string>
    <string name="dump_heap_text" msgid="1692649033835719336">"Proces <xliff:g id="PROC">%1$s</xliff:g> je presegel omejitev pomnilnika, ki je <xliff:g id="SIZE">%2$s</xliff:g>. Na voljo je izvoz kopice, ki ga lahko delite z razvijalcem. Previdno: izvoz kopice lahko vsebuje osebne podatke, do katerih ima aplikacija dostop."</string>
    <string name="dump_heap_system_text" msgid="6805155514925350849">"Proces <xliff:g id="PROC">%1$s</xliff:g> je presegel predvideno omejitev pomnilnika <xliff:g id="SIZE">%2$s</xliff:g>. Izvoz kopice je na voljo za deljenje z drugimi. Previdno: izvoz kopice morda vsebuje občutljive osebne podatke, do katerih ima proces dostop, vključno z vašimi vnosi."</string>
    <string name="dump_heap_ready_text" msgid="5849618132123045516">"Na voljo je izvoz kopice procesa <xliff:g id="PROC">%1$s</xliff:g>, ki ga lahko delite z drugimi. Previdno: izvoz kopice morda vsebuje občutljive osebne podatke, do katerih ima proces dostop, vključno z vašimi vnosi."</string>
    <string name="sendText" msgid="493003724401350724">"Izberite dejanje za besedilo"</string>
    <string name="volume_ringtone" msgid="134784084629229029">"Glasnost zvonjenja"</string>
    <string name="volume_music" msgid="7727274216734955095">"Glasnost predstavnosti"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="2614142915948898228">"Predvajanje prek sistema Bluetooth"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="1514829655029062233">"Nastavljena je tiha melodija zvonjenja"</string>
    <string name="volume_call" msgid="7625321655265747433">"Glasnost dohodnih klicev"</string>
    <string name="volume_bluetooth_call" msgid="2930204618610115061">"Glasnost funkcije Bluetooth v avtomobilu"</string>
    <string name="volume_alarm" msgid="4486241060751798448">"Glasnost alarma"</string>
    <string name="volume_notification" msgid="6864412249031660057">"Glasnost obvestila"</string>
    <string name="volume_unknown" msgid="4041914008166576293">"Glasnost"</string>
    <string name="volume_icon_description_bluetooth" msgid="7540388479345558400">"Glasnost Bluetootha"</string>
    <string name="volume_icon_description_ringer" msgid="2187800636867423459">"Glasnost zvonjenja"</string>
    <string name="volume_icon_description_incall" msgid="4491255105381227919">"Glasnost klica"</string>
    <string name="volume_icon_description_media" msgid="4997633254078171233">"Glasnost predstavnosti"</string>
    <string name="volume_icon_description_notification" msgid="579091344110747279">"Glasnost obvestila"</string>
    <string name="ringtone_default" msgid="9118299121288174597">"Privzeta melodija zvonjenja"</string>
    <string name="ringtone_default_with_actual" msgid="2709686194556159773">"Privzeto (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="397111123930141876">"Brez"</string>
    <string name="ringtone_picker_title" msgid="667342618626068253">"Melodije zvonjenja"</string>
    <string name="ringtone_picker_title_alarm" msgid="7438934548339024767">"Zvoki alarma"</string>
    <string name="ringtone_picker_title_notification" msgid="6387191794719608122">"Zvoki obvestil"</string>
    <string name="ringtone_unknown" msgid="5059495249862816475">"Neznano"</string>
    <string name="wifi_available_sign_in" msgid="381054692557675237">"Prijavite se v omrežje Wi-Fi"</string>
    <string name="network_available_sign_in" msgid="1520342291829283114">"Prijava v omrežje"</string>
    <!-- no translation found for network_available_sign_in_detailed (7520423801613396556) -->
    <skip />
    <string name="wifi_no_internet" msgid="1386911698276448061">"Omrežje <xliff:g id="NETWORK_SSID">%1$s</xliff:g> nima dostopa do interneta"</string>
    <string name="wifi_no_internet_detailed" msgid="634938444133558942">"Dotaknite se za možnosti"</string>
    <string name="mobile_no_internet" msgid="4014455157529909781">"Mobilno omrežje nima dostopa do interneta"</string>
    <string name="other_networks_no_internet" msgid="6698711684200067033">"Omrežje nima dostopa do interneta"</string>
    <string name="private_dns_broken_detailed" msgid="3709388271074611847">"Do zasebnega strežnika DNS ni mogoče dostopati"</string>
    <string name="network_partial_connectivity" msgid="4791024923851432291">"Povezljivost omrežja <xliff:g id="NETWORK_SSID">%1$s</xliff:g> je omejena"</string>
    <string name="network_partial_connectivity_detailed" msgid="5741329444564575840">"Dotaknite se, da kljub temu vzpostavite povezavo"</string>
    <string name="network_switch_metered" msgid="1531869544142283384">"Preklopljeno na omrežje vrste <xliff:g id="NETWORK_TYPE">%1$s</xliff:g>"</string>
    <string name="network_switch_metered_detail" msgid="1358296010128405906">"Naprava uporabi omrežje vrste <xliff:g id="NEW_NETWORK">%1$s</xliff:g>, ko omrežje vrste <xliff:g id="PREVIOUS_NETWORK">%2$s</xliff:g> nima dostopa do interneta. Prenos podatkov se lahko zaračuna."</string>
    <string name="network_switch_metered_toast" msgid="501662047275723743">"Preklopljeno z omrežja vrste <xliff:g id="PREVIOUS_NETWORK">%1$s</xliff:g> na omrežje vrste <xliff:g id="NEW_NETWORK">%2$s</xliff:g>"</string>
  <string-array name="network_switch_type_name">
    <item msgid="2255670471736226365">"prenos podatkov v mobilnem omrežju"</item>
    <item msgid="5520925862115353992">"Wi-Fi"</item>
    <item msgid="1055487873974272842">"Bluetooth"</item>
    <item msgid="1616528372438698248">"Ethernet"</item>
    <item msgid="9177085807664964627">"VPN"</item>
  </string-array>
    <string name="network_switch_type_name_unknown" msgid="3665696841646851068">"neznana vrsta omrežja"</string>
    <string name="accept" msgid="5447154347815825107">"Sprejmem"</string>
    <string name="decline" msgid="6490507610282145874">"Zavrni"</string>
    <string name="select_character" msgid="3352797107930786979">"Vstavljanje znaka"</string>
    <string name="sms_control_title" msgid="4748684259903148341">"Pošiljanje sporočil SMS"</string>
    <string name="sms_control_message" msgid="6574313876316388239">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; pošilja veliko SMS-ov. Ali želite dovoliti, da jih še naprej pošilja?"</string>
    <string name="sms_control_yes" msgid="4858845109269524622">"Dovoli"</string>
    <string name="sms_control_no" msgid="4845717880040355570">"Zavrni"</string>
    <string name="sms_short_code_confirm_message" msgid="1385416688897538724">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; želi poslati sporočilo na &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="2723725738333388351">"S tem "<b>"bo morda bremenjen račun"</b>" za vašo mobilno napravo."</string>
    <string name="sms_premium_short_code_details" msgid="1400296309866638111"><b>"S tem bo bremenjen vaš račun za mobilno napravo."</b></string>
    <string name="sms_short_code_confirm_allow" msgid="920477594325526691">"Pošlji"</string>
    <string name="sms_short_code_confirm_deny" msgid="1356917469323768230">"Prekliči"</string>
    <string name="sms_short_code_remember_choice" msgid="1374526438647744862">"Zapomni si mojo izbiro"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="2620984439143080410">"To lahko pozneje spremenite v Nastavitve &gt; Aplikacije"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="2223014893129755950">"Vedno dovoli"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="2688828813521652079">"Nikoli ne dovoli"</string>
    <string name="sim_removed_title" msgid="5387212933992546283">"Kartica SIM odstranjena"</string>
    <string name="sim_removed_message" msgid="9051174064474904617">"Mobilno omrežje ne bo na voljo, dokler naprave vnovič ne zaženete z veljavno kartico SIM."</string>
    <string name="sim_done_button" msgid="6464250841528410598">"Dokončano"</string>
    <string name="sim_added_title" msgid="7930779986759414595">"Kartica SIM dodana"</string>
    <string name="sim_added_message" msgid="6602906609509958680">"Za dostop do mobilnega omrežja znova zaženite napravo."</string>
    <string name="sim_restart_button" msgid="8481803851341190038">"Vnovičen zagon"</string>
    <string name="install_carrier_app_notification_title" msgid="5712723402213090102">"Aktivirajte mobilno storitev"</string>
    <string name="install_carrier_app_notification_text" msgid="2781317581274192728">"Prenesite aplikacijo operaterja, da boste lahko aktivirali novo kartico SIM"</string>
    <string name="install_carrier_app_notification_text_app_name" msgid="4086877327264106484">"Prenesite aplikacijo <xliff:g id="APP_NAME">%1$s</xliff:g>, da boste lahko aktivirali novo kartico SIM"</string>
    <string name="install_carrier_app_notification_button" msgid="6257740533102594290">"Prenos aplikacije"</string>
    <string name="carrier_app_notification_title" msgid="5815477368072060250">"Nova kartica SIM je vstavljena"</string>
    <string name="carrier_app_notification_text" msgid="6567057546341958637">"Dotaknite se za nastavitev"</string>
    <string name="time_picker_dialog_title" msgid="9053376764985220821">"Nastavi uro"</string>
    <string name="date_picker_dialog_title" msgid="5030520449243071926">"Nastavi datum"</string>
    <string name="date_time_set" msgid="4603445265164486816">"Nastavi"</string>
    <string name="date_time_done" msgid="8363155889402873463">"Končano"</string>
    <string name="perms_new_perm_prefix" msgid="6984556020395757087"><font size="12" fgcolor="#ff33b5e5">"NOVO: "</font></string>
    <string name="perms_description_app" msgid="2747752389870161996">"Zagotavlja aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="no_permissions" msgid="5729199278862516390">"Ni zahtevanih dovoljenj"</string>
    <string name="perm_costs_money" msgid="749054595022779685">"to je lahko plačljivo"</string>
    <string name="dlg_ok" msgid="5103447663504839312">"V redu"</string>
    <string name="usb_charging_notification_title" msgid="1674124518282666955">"Polnjenje akumulatorja v napravi prek USB-ja"</string>
    <string name="usb_supplying_notification_title" msgid="5378546632408101811">"Polnjenje akumulatorja v povezani napravi prek USB-ja"</string>
    <string name="usb_mtp_notification_title" msgid="1065989144124499810">"Vklopljen je prenos datotek prek USB-ja"</string>
    <string name="usb_ptp_notification_title" msgid="5043437571863443281">"Vklopljen je način PTP prek USB-ja"</string>
    <string name="usb_tether_notification_title" msgid="8828527870612663771">"Vklopljen je internet prek USB-ja"</string>
    <string name="usb_midi_notification_title" msgid="7404506788950595557">"Vklopljen je način MIDI prek USB-ja"</string>
    <string name="usb_accessory_notification_title" msgid="1385394660861956980">"Dodatek USB je priključen"</string>
    <string name="usb_notification_message" msgid="4715163067192110676">"Dotaknite se za več možnosti."</string>
    <string name="usb_power_notification_message" msgid="7284765627437897702">"Polnjenje akumulatorja v povezani napravi. Dotaknite se za več možnosti."</string>
    <string name="usb_unsupported_audio_accessory_title" msgid="2335775548086533065">"Zaznana je analogna dodatna zvočna oprema"</string>
    <string name="usb_unsupported_audio_accessory_message" msgid="1300168007129796621">"Priključena naprava ni združljiva s tem telefonom. Dotaknite se za več informacij."</string>
    <string name="adb_active_notification_title" msgid="408390247354560331">"Iskanje napak prek USB je povezano"</string>
    <string name="adb_active_notification_message" msgid="5617264033476778211">"Dotaknite se, če želite izklop. odpravlj. napak prek USB-ja"</string>
    <string name="adb_active_notification_message" product="tv" msgid="6624498401272780855">"Izberite, če želite onemogočiti iskanje in odpravljanje napak prek vrat USB."</string>
    <string name="adbwifi_active_notification_title" msgid="6147343659168302473">"Povezava za brezžično odpravljanje napak je vzpostavljena"</string>
    <string name="adbwifi_active_notification_message" msgid="930987922852867972">"Dotaknite se, če želite izklopiti brezžično odpravljanje napak."</string>
    <string name="adbwifi_active_notification_message" product="tv" msgid="8633421848366915478">"Izberite, če želite onemogočiti brezžično odpravljanje napak."</string>
    <string name="test_harness_mode_notification_title" msgid="2282785860014142511">"Način preizkusnega ogrodja je omogočen"</string>
    <string name="test_harness_mode_notification_message" msgid="3039123743127958420">"Če želite onemogočiti način preizkusnega ogrodja, ponastavite napravo na tovarniške nastavitve."</string>
    <string name="console_running_notification_title" msgid="6087888939261635904">"Serijska konzola je omogočena"</string>
    <string name="console_running_notification_message" msgid="7892751888125174039">"Učinkovitost delovanja je slabša. Uporabo konzole lahko onemogočite v zagonskem nalagalniku."</string>
    <string name="usb_contaminant_detected_title" msgid="4359048603069159678">"V vratih USB je tekočina ali umazanija"</string>
    <string name="usb_contaminant_detected_message" msgid="7346100585390795743">"Vrata USB so samodejno onemogočena. Dotaknite se, če želite izvedeti več."</string>
    <string name="usb_contaminant_not_detected_title" msgid="2651167729563264053">"Vrata USB so varna za uporabo"</string>
    <string name="usb_contaminant_not_detected_message" msgid="892863190942660462">"Telefon ne zaznava več tekočine ali umazanije."</string>
    <string name="taking_remote_bugreport_notification_title" msgid="1582531382166919850">"Zajemanje poročila o napakah …"</string>
    <string name="share_remote_bugreport_notification_title" msgid="6708897723753334999">"Želite poslati poročilo o napakah?"</string>
    <string name="sharing_remote_bugreport_notification_title" msgid="3077385149217638550">"Pošiljanje poročila o napakah …"</string>
    <string name="share_remote_bugreport_notification_message_finished" msgid="7325635795739260135">"Skrbnik je zahteval poročilo o napakah za pomoč pri odpravljanju napak v tej napravi. Aplikacije in podatki bodo morda dani v skupno rabo."</string>
    <string name="share_remote_bugreport_action" msgid="7630880678785123682">"SKUPNA RABA"</string>
    <string name="decline_remote_bugreport_action" msgid="4040894777519784346">"NE SPREJMEM"</string>
    <string name="select_input_method" msgid="3971267998568587025">"Izberite način vnosa"</string>
    <string name="show_ime" msgid="6406112007347443383">"Ohrani na zaslonu, dokler je aktivna fizična tipkovnica"</string>
    <string name="hardware" msgid="1800597768237606953">"Pokaži navidezno tipkovnico"</string>
    <string name="select_keyboard_layout_notification_title" msgid="4427643867639774118">"Konfiguriranje fizične tipkovnice"</string>
    <string name="select_keyboard_layout_notification_message" msgid="8835158247369158154">"Dotaknite se, če želite izbrati jezik in postavitev."</string>
    <string name="fast_scroll_alphabet" msgid="8854435958703888376">" ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="2529539945421557329">" 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="alert_windows_notification_channel_group_name" msgid="6063891141815714246">"Prekrivanje drugih aplikacij"</string>
    <string name="alert_windows_notification_channel_name" msgid="3437528564303192620">"<xliff:g id="NAME">%s</xliff:g> prekriva druge aplikacije"</string>
    <string name="alert_windows_notification_title" msgid="6331662751095228536">"<xliff:g id="NAME">%s</xliff:g> prekriva druge aplikacije"</string>
    <string name="alert_windows_notification_message" msgid="6538171456970725333">"Če ne želite, da aplikacija <xliff:g id="NAME">%s</xliff:g> uporablja to funkcijo, se dotaknite, da odprete nastavitve, in funkcijo izklopite."</string>
    <string name="alert_windows_notification_turn_off_action" msgid="7805857234839123780">"Izklopi"</string>
    <string name="ext_media_checking_notification_title" msgid="8299199995416510094">"Preverjanje nosilca <xliff:g id="NAME">%s</xliff:g> …"</string>
    <string name="ext_media_checking_notification_message" msgid="2231566971425375542">"Pregledovanje trenutne vsebine"</string>
    <string name="ext_media_new_notification_title" msgid="3517407571407687677">"Nova naprava za shranjevanje: <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_new_notification_message" msgid="6095403121990786986">"Dotaknite se, če želite nastaviti"</string>
    <string name="ext_media_new_notification_message" product="automotive" msgid="8488046026389025694"></string>
    <string name="ext_media_ready_notification_message" msgid="777258143284919261">"Za prenos fotografij in predstavnosti"</string>
    <string name="ext_media_unmountable_notification_title" msgid="4895444667278979910">"Težava z nosilcem <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unmountable_notification_message" msgid="3256290114063126205">"Dotaknite se, da to popravite"</string>
    <string name="ext_media_unmountable_notification_message" product="tv" msgid="3003611129979934633">"Nosilec <xliff:g id="NAME">%s</xliff:g> je pokvarjen. Izberite, če ga želite popraviti."</string>
    <string name="ext_media_unmountable_notification_message" product="automotive" msgid="5622514265490819212"></string>
    <string name="ext_media_unsupported_notification_title" msgid="4358280700537030333">"Nepodprta naprava za shran. <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unsupported_notification_message" msgid="917738524888367560">"Ta naprava ne podpira tega nosilca <xliff:g id="NAME">%s</xliff:g>. Dotaknite se, če želite nastaviti v podprti obliki."</string>
    <string name="ext_media_unsupported_notification_message" product="tv" msgid="7744945987775645685">"Naprava ne podpira nosilca <xliff:g id="NAME">%s</xliff:g>. Izberite, če ga želite nastaviti v podprti obliki."</string>
    <string name="ext_media_unsupported_notification_message" product="automotive" msgid="7657357085538772913">"Ta naprava ne podpira nosilca <xliff:g id="NAME">%s</xliff:g>."</string>
    <string name="ext_media_badremoval_notification_title" msgid="4114625551266196872">"Shramba <xliff:g id="NAME">%s</xliff:g> nepričak. odstranjena"</string>
    <string name="ext_media_badremoval_notification_message" msgid="1986514704499809244">"Medij izvrzite, preden ga odstranite, da se izognete izgubi vsebine"</string>
    <string name="ext_media_nomedia_notification_title" msgid="742671636376975890">"Nosilec <xliff:g id="NAME">%s</xliff:g> je odstranjen"</string>
    <string name="ext_media_nomedia_notification_message" msgid="2832724384636625852">"Nekatere funkcije morda ne bodo pravilno delovale. Vstavite novo napravo za shranjevanje."</string>
    <string name="ext_media_unmounting_notification_title" msgid="4147986383917892162">"Izvrženje nosilca <xliff:g id="NAME">%s</xliff:g> …"</string>
    <string name="ext_media_unmounting_notification_message" msgid="5717036261538754203">"Ne odstranite"</string>
    <string name="ext_media_init_action" msgid="2312974060585056709">"Nastavi"</string>
    <string name="ext_media_unmount_action" msgid="966992232088442745">"Izvrzite"</string>
    <string name="ext_media_browse_action" msgid="344865351947079139">"Raziščite"</string>
    <string name="ext_media_seamless_action" msgid="8837030226009268080">"Preklopite izhod"</string>
    <string name="ext_media_missing_title" msgid="3209472091220515046">"Ni shrambe <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_missing_message" msgid="4408988706227922909">"Znova vstavite napravo"</string>
    <string name="ext_media_move_specific_title" msgid="8492118544775964250">"Premikanje aplikacije <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_title" msgid="2682741525619033637">"Premikanje podatkov"</string>
    <string name="ext_media_move_success_title" msgid="4901763082647316767">"Prenos vsebine je končan"</string>
    <string name="ext_media_move_success_message" msgid="9159542002276982979">"Vsebina je bila premaknjena v napravo za shranjevanje <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_failure_title" msgid="3184577479181333665">"Vsebine ni bilo mogoče premakniti"</string>
    <string name="ext_media_move_failure_message" msgid="4197306718121869335">"Poskusite znova premakniti vsebino"</string>
    <string name="ext_media_status_removed" msgid="241223931135751691">"Odstranjeno"</string>
    <string name="ext_media_status_unmounted" msgid="8145812017295835941">"Izvrženo"</string>
    <string name="ext_media_status_checking" msgid="159013362442090347">"Preverjanje ..."</string>
    <string name="ext_media_status_mounted" msgid="3459448555811203459">"Pripravljeno"</string>
    <string name="ext_media_status_mounted_ro" msgid="1974809199760086956">"Samo za branje"</string>
    <string name="ext_media_status_bad_removal" msgid="508448566481406245">"Ni bilo varno odstranjeno"</string>
    <string name="ext_media_status_unmountable" msgid="7043574843541087748">"Poškodovano"</string>
    <string name="ext_media_status_unsupported" msgid="5460509911660539317">"Ni podprto"</string>
    <string name="ext_media_status_ejecting" msgid="7532403368044013797">"Izvrženje poteka …"</string>
    <string name="ext_media_status_formatting" msgid="774148701503179906">"Formatiranje ..."</string>
    <string name="ext_media_status_missing" msgid="6520746443048867314">"Ni vstavljeno"</string>
    <string name="activity_list_empty" msgid="4219430010716034252">"Ni ustreznih dejavnosti."</string>
    <string name="permlab_route_media_output" msgid="8048124531439513118">"preusmeritev predstavnosti"</string>
    <string name="permdesc_route_media_output" msgid="1759683269387729675">"Aplikaciji omogoča preusmerjanje predstavnosti v druge zunanje naprave."</string>
    <string name="permlab_readInstallSessions" msgid="7279049337895583621">"branje sej namestitev"</string>
    <string name="permdesc_readInstallSessions" msgid="4012608316610763473">"Aplikaciji omogoča branje sej namestitev. Tako lahko bere podrobnosti o aktivnih namestitvah paketov."</string>
    <string name="permlab_requestInstallPackages" msgid="7600020863445351154">"zahtevanje paketov za namestitev"</string>
    <string name="permdesc_requestInstallPackages" msgid="3969369278325313067">"Aplikaciji omogoča zahtevanje namestitve paketov."</string>
    <string name="permlab_requestDeletePackages" msgid="2541172829260106795">"Zahteva za brisanje paketov"</string>
    <string name="permdesc_requestDeletePackages" msgid="6133633516423860381">"Omogoča aplikaciji, da zahteva brisanje paketov."</string>
    <string name="permlab_requestIgnoreBatteryOptimizations" msgid="7646611326036631439">"Dovoljenje za prezrtje optimizacij baterije"</string>
    <string name="permdesc_requestIgnoreBatteryOptimizations" msgid="634260656917874356">"Aplikaciji dovoljuje, da vpraša za dovoljenje, ali naj prezre optimizacije baterije."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="1842872462124648678">"Tapnite dvakrat za nadzor povečave/pomanjšave"</string>
    <string name="gadget_host_error_inflating" msgid="2449961590495198720">"Pripomočka ni bilo mogoče dodati."</string>
    <string name="ime_action_go" msgid="5536744546326495436">"Pojdi"</string>
    <string name="ime_action_search" msgid="4501435960587287668">"Iskanje"</string>
    <string name="ime_action_send" msgid="8456843745664334138">"Pošlji"</string>
    <string name="ime_action_next" msgid="4169702997635728543">"Naprej"</string>
    <string name="ime_action_done" msgid="6299921014822891569">"Dokončano"</string>
    <string name="ime_action_previous" msgid="6548799326860401611">"Nazaj"</string>
    <string name="ime_action_default" msgid="8265027027659800121">"Izvedi"</string>
    <string name="dial_number_using" msgid="6060769078933953531">"Pokliči številko\ns številko <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="6200708808003692594">"Ustvari stik\ns številko <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="5365733888842570481">"Te aplikacije zahtevajo dovoljenje za dostop do računa zdaj in v prihodnje."</string>
    <string name="grant_credentials_permission_message_footer" msgid="1886710210516246461">"Ali želite to zahtevo dovoliti?"</string>
    <string name="grant_permissions_header_text" msgid="3420736827804657201">"Zahteva za dostop"</string>
    <string name="allow" msgid="6195617008611933762">"Dovoli"</string>
    <string name="deny" msgid="6632259981847676572">"Zavrni"</string>
    <string name="permission_request_notification_title" msgid="1810025922441048273">"Zahtevano je dovoljenje"</string>
    <string name="permission_request_notification_with_subtitle" msgid="3743417870360129298">"Zahtevano je dovoljenje\nza račun <xliff:g id="ACCOUNT">%s</xliff:g>."</string>
    <string name="forward_intent_to_owner" msgid="4620359037192871015">"Aplikacijo uporabljate zunaj delovnega profila"</string>
    <string name="forward_intent_to_work" msgid="3620262405636021151">"To aplikacijo uporabljate v delovnem profilu"</string>
    <string name="input_method_binding_label" msgid="1166731601721983656">"Način vnosa"</string>
    <string name="sync_binding_label" msgid="469249309424662147">"Sinhronizacija"</string>
    <string name="accessibility_binding_label" msgid="1974602776545801715">"Pripomočki za osebe s posebnimi potrebami"</string>
    <string name="wallpaper_binding_label" msgid="1197440498000786738">"Ozadje"</string>
    <string name="chooser_wallpaper" msgid="3082405680079923708">"Spreminjanje ozadja"</string>
    <string name="notification_listener_binding_label" msgid="2702165274471499713">"Poslušalec obvestil"</string>
    <string name="vr_listener_binding_label" msgid="8013112996671206429">"Poslušalec za VR"</string>
    <string name="condition_provider_service_binding_label" msgid="8490641013951857673">"Ponudnik pogojev"</string>
    <string name="notification_ranker_binding_label" msgid="432708245635563763">"Storitev za določanje stopenj pomembnosti obvestil"</string>
    <string name="vpn_title" msgid="5906991595291514182">"VPN aktiviran"</string>
    <string name="vpn_title_long" msgid="6834144390504619998">"VPN je aktivirala aplikacija <xliff:g id="APP">%s</xliff:g>"</string>
    <string name="vpn_text" msgid="2275388920267251078">"Tapnite za upravljanje omrežja."</string>
    <string name="vpn_text_long" msgid="278540576806169831">"Povezan z mestom <xliff:g id="SESSION">%s</xliff:g>. Tapnite za upravljanje omrežja."</string>
    <string name="vpn_lockdown_connecting" msgid="6096725311950342607">"Povezovanje v stalno vklopljeno navidezno zasebno omrežje ..."</string>
    <string name="vpn_lockdown_connected" msgid="2853127976590658469">"Vzpostavljena povezava v stalno vklopljeno navidezno zasebno omrežje"</string>
    <string name="vpn_lockdown_disconnected" msgid="5573611651300764955">"Prekinjena povezava s stalno vklopljenim VPN-jem"</string>
    <string name="vpn_lockdown_error" msgid="4453048646854247947">"Povezave s stalno vklopljenim VPN-jem ni bilo mogoče vzpostaviti"</string>
    <string name="vpn_lockdown_config" msgid="8331697329868252169">"Spremenite omrežne nastavitve ali nastavitve omrežja VPN"</string>
    <string name="upload_file" msgid="8651942222301634271">"Izberi datoteko"</string>
    <string name="no_file_chosen" msgid="4146295695162318057">"Nobena datoteka ni izbrana"</string>
    <string name="reset" msgid="3865826612628171429">"Ponastavi"</string>
    <string name="submit" msgid="862795280643405865">"Pošlji"</string>
    <string name="car_mode_disable_notification_title" msgid="8450693275833142896">"Aplikacija za vožnjo se izvaja"</string>
    <string name="car_mode_disable_notification_message" msgid="8954550232288567515">"Dotaknite se, če želite zapreti aplikacijo za vožnjo."</string>
    <string name="back_button_label" msgid="4078224038025043387">"Nazaj"</string>
    <string name="next_button_label" msgid="6040209156399907780">"Naprej"</string>
    <string name="skip_button_label" msgid="3566599811326688389">"Preskoči"</string>
    <string name="no_matches" msgid="6472699895759164599">"Ni ujemanj"</string>
    <string name="find_on_page" msgid="5400537367077438198">"Najdi na strani"</string>
    <plurals name="matches_found" formatted="false" msgid="1101758718194295554">
      <item quantity="one"><xliff:g id="INDEX">%d</xliff:g> od <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="two"><xliff:g id="INDEX">%d</xliff:g> od <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="few"><xliff:g id="INDEX">%d</xliff:g> od <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="other"><xliff:g id="INDEX">%d</xliff:g> od <xliff:g id="TOTAL">%d</xliff:g></item>
    </plurals>
    <string name="action_mode_done" msgid="2536182504764803222">"Končano"</string>
    <string name="progress_erasing" msgid="6891435992721028004">"Brisanje skupne shrambe …"</string>
    <string name="share" msgid="4157615043345227321">"Deli"</string>
    <string name="find" msgid="5015737188624767706">"Najdi"</string>
    <string name="websearch" msgid="5624340204512793290">"Spletno iskanje"</string>
    <string name="find_next" msgid="5341217051549648153">"Najdi naslednje"</string>
    <string name="find_previous" msgid="4405898398141275532">"Najdi prejšnje"</string>
    <string name="gpsNotifTicker" msgid="3207361857637620780">"Zahteva za lokacijo uporabnika <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="1590033371665669570">"Zahteva za lokacijo"</string>
    <string name="gpsNotifMessage" msgid="7346649122793758032">"Zahtevala oseba <xliff:g id="NAME">%1$s</xliff:g> (<xliff:g id="SERVICE">%2$s</xliff:g>)"</string>
    <string name="gpsVerifYes" msgid="3719843080744112940">"Da"</string>
    <string name="gpsVerifNo" msgid="1671201856091564741">"Ne"</string>
    <string name="gnss_nfw_notification_title" msgid="5004493772059563423">"Dostop do lokacije med klicem v sili"</string>
    <string name="gnss_nfw_notification_message_oem" msgid="3683958907027107969">"Med nedavnim klicem v sili je proizvajalec naprave dostopil do vaše lokacije"</string>
    <string name="gnss_nfw_notification_message_carrier" msgid="815888995791562151">"Med nedavnim klicem v sili je operater dostopil do vaše lokacije"</string>
    <string name="sync_too_many_deletes" msgid="6999440774578705300">"Omejitev brisanja je presežena"</string>
    <string name="sync_too_many_deletes_desc" msgid="7409327940303504440">"Št. izbrisanih elementov za <xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g> v računu <xliff:g id="ACCOUNT_NAME">%3$s</xliff:g>: <xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g>. Kaj želite narediti?"</string>
    <string name="sync_really_delete" msgid="5657871730315579051">"Izbris elementov"</string>
    <string name="sync_undo_deletes" msgid="5786033331266418896">"Razveljavi brisanja"</string>
    <string name="sync_do_nothing" msgid="4528734662446469646">"Za zdaj ne naredi ničesar"</string>
    <string name="choose_account_label" msgid="5557833752759831548">"Izberite račun"</string>
    <string name="add_account_label" msgid="4067610644298737417">"Dodajanje računa"</string>
    <string name="add_account_button_label" msgid="322390749416414097">"Dodaj račun"</string>
    <string name="number_picker_increment_button" msgid="7621013714795186298">"Več"</string>
    <string name="number_picker_decrement_button" msgid="5116948444762708204">"Manj"</string>
    <string name="number_picker_increment_scroll_mode" msgid="8403893549806805985">"Dotaknite se vrednosti <xliff:g id="VALUE">%s</xliff:g> in jo pridržite."</string>
    <string name="number_picker_increment_scroll_action" msgid="8310191318914268271">"Povlecite navzgor za povečanje in navzdol za zmanjšanje."</string>
    <string name="time_picker_increment_minute_button" msgid="7195870222945784300">"Povečanje vrednosti za minuto"</string>
    <string name="time_picker_decrement_minute_button" msgid="230925389943411490">"Zmanjšanje vrednosti za minuto"</string>
    <string name="time_picker_increment_hour_button" msgid="3063572723197178242">"Povečanje vrednosti za uro"</string>
    <string name="time_picker_decrement_hour_button" msgid="584101766855054412">"Zmanjšanje vrednosti za uro"</string>
    <string name="time_picker_increment_set_pm_button" msgid="5889149366900376419">"Nastavi PM"</string>
    <string name="time_picker_decrement_set_am_button" msgid="1422608001541064087">"Nastavi AM"</string>
    <string name="date_picker_increment_month_button" msgid="3447263316096060309">"Povečanje vrednosti za mesec"</string>
    <string name="date_picker_decrement_month_button" msgid="6531888937036883014">"Zmanjšanje vrednosti za mesec"</string>
    <string name="date_picker_increment_day_button" msgid="4349336637188534259">"Povečanje vrednosti za dan"</string>
    <string name="date_picker_decrement_day_button" msgid="6840253837656637248">"Zmanjšanje vrednosti za dan"</string>
    <string name="date_picker_increment_year_button" msgid="7608128783435372594">"Povečanje vrednosti za leto"</string>
    <string name="date_picker_decrement_year_button" msgid="4102586521754172684">"Zmanjšanje vrednosti za leto"</string>
    <string name="date_picker_prev_month_button" msgid="3418694374017868369">"Prejšnji mesec"</string>
    <string name="date_picker_next_month_button" msgid="4858207337779144840">"Naslednji mesec"</string>
    <string name="keyboardview_keycode_alt" msgid="8997420058584292385">"Tipka Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="2134624484115716975">"Prekliči"</string>
    <string name="keyboardview_keycode_delete" msgid="2661117313730098650">"Tipka Delete"</string>
    <string name="keyboardview_keycode_done" msgid="2524518019001653851">"Končano"</string>
    <string name="keyboardview_keycode_mode_change" msgid="2743735349997999020">"Sprememba načina"</string>
    <string name="keyboardview_keycode_shift" msgid="3026509237043975573">"Tipka Shift"</string>
    <string name="keyboardview_keycode_enter" msgid="168054869339091055">"Tipka Enter"</string>
    <string name="activitychooserview_choose_application" msgid="3500574466367891463">"Izberite aplikacijo"</string>
    <string name="activitychooserview_choose_application_error" msgid="6937782107559241734">"Aplikacije <xliff:g id="APPLICATION_NAME">%s</xliff:g> ni bilo mogoče zagnati"</string>
    <string name="shareactionprovider_share_with" msgid="2753089758467748982">"Delite z"</string>
    <string name="shareactionprovider_share_with_application" msgid="4902832247173666973">"Delite z aplikacijo <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="982510275422590757">"Drsna ročica. Dotaknite se in pridržite."</string>
    <string name="description_target_unlock_tablet" msgid="7431571180065859551">"Povlecite, če želite odkleniti."</string>
    <string name="action_bar_home_description" msgid="1501655419158631974">"Krmarjenje domov"</string>
    <string name="action_bar_up_description" msgid="6611579697195026932">"Krmarjenje navzgor"</string>
    <string name="action_menu_overflow_description" msgid="4579536843510088170">"Več možnosti"</string>
    <string name="action_bar_home_description_format" msgid="5087107531331621803">"%1$s, %2$s"</string>
    <string name="action_bar_home_subtitle_description_format" msgid="4346835454749569826">"%1$s, %2$s, %3$s"</string>
    <string name="storage_internal" msgid="8490227947584914460">"Notranja shramba v skupni rabi"</string>
    <string name="storage_sd_card" msgid="3404740277075331881">"Kartica SD"</string>
    <string name="storage_sd_card_label" msgid="7526153141147470509">"Kartica SD <xliff:g id="MANUFACTURER">%s</xliff:g>"</string>
    <string name="storage_usb_drive" msgid="448030813201444573">"Pogon USB"</string>
    <string name="storage_usb_drive_label" msgid="6631740655876540521">"Pogon USB <xliff:g id="MANUFACTURER">%s</xliff:g>"</string>
    <string name="storage_usb" msgid="2391213347883616886">"Pomnilnik USB"</string>
    <string name="extract_edit_menu_button" msgid="63954536535863040">"Uredi"</string>
    <string name="data_usage_warning_title" msgid="9034893717078325845">"Opozorilo o prenosu podatkov"</string>
    <string name="data_usage_warning_body" msgid="1669325367188029454">"Porabili ste <xliff:g id="APP">%s</xliff:g> podatkov"</string>
    <string name="data_usage_mobile_limit_title" msgid="3911447354393775241">"Omej. pren. mob. pod. dosežena"</string>
    <string name="data_usage_wifi_limit_title" msgid="2069698056520812232">"Dosežena pod. omejitev za Wi-Fi"</string>
    <string name="data_usage_limit_body" msgid="3567699582000085710">"Prenos podatkov je zaustavljen do konca obračunskega obdobja"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="101888478915677895">"Prek omejitve mobilnih podatkov"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="1622359254521960508">"Prek omejitve podatkov Wi-Fi"</string>
    <string name="data_usage_limit_snoozed_body" msgid="545146591766765678">"Nastavljeno omejitev ste presegli za <xliff:g id="SIZE">%s</xliff:g>"</string>
    <string name="data_usage_restricted_title" msgid="126711424380051268">"Podatki v ozadju so omejeni"</string>
    <string name="data_usage_restricted_body" msgid="5338694433686077733">"Dotaknite se za odstr. omejitve."</string>
    <string name="data_usage_rapid_title" msgid="2950192123248740375">"Velik prenos mobilnih podatkov"</string>
    <string name="data_usage_rapid_body" msgid="3886676853263693432">"Vaše aplikacije so porabile več podatkov kot običajno"</string>
    <string name="data_usage_rapid_app_body" msgid="5425779218506513861">"Aplikacija <xliff:g id="APP">%s</xliff:g> je porabila več podatkov kot običajno"</string>
    <string name="ssl_certificate" msgid="5690020361307261997">"Varnostno potrdilo"</string>
    <string name="ssl_certificate_is_valid" msgid="7293675884598527081">"To potrdilo je veljavno."</string>
    <string name="issued_to" msgid="5975877665505297662">"Izdano za:"</string>
    <string name="common_name" msgid="1486334593631798443">"Pravo ime:"</string>
    <string name="org_name" msgid="7526331696464255245">"Organizacija:"</string>
    <string name="org_unit" msgid="995934486977223076">"Organizacijska enota:"</string>
    <string name="issued_by" msgid="7872459822431585684">"Izdal:"</string>
    <string name="validity_period" msgid="1717724283033175968">"Veljavnost:"</string>
    <string name="issued_on" msgid="5855489688152497307">"Izdano:"</string>
    <string name="expires_on" msgid="1623640879705103121">"Velja do:"</string>
    <string name="serial_number" msgid="3479576915806623429">"Serijska številka:"</string>
    <string name="fingerprints" msgid="148690767172613723">"Prstni odtisi:"</string>
    <string name="sha256_fingerprint" msgid="7103976380961964600">"Prstni odtis SHA-256:"</string>
    <string name="sha1_fingerprint" msgid="2339915142825390774">"Prstni odtis SHA-1:"</string>
    <string name="activity_chooser_view_see_all" msgid="3917045206812726099">"Pokaži vse"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="8880731437191978314">"Izberite dejavnost"</string>
    <string name="share_action_provider_share_with" msgid="1904096863622941880">"Delite z"</string>
    <string name="sending" msgid="206925243621664438">"Pošiljanje ..."</string>
    <string name="launchBrowserDefault" msgid="6328349989932924119">"Ali želite odpreti brskalnik?"</string>
    <string name="SetupCallDefault" msgid="5581740063237175247">"Ali želite sprejeti klic?"</string>
    <string name="activity_resolver_use_always" msgid="5575222334666843269">"Vedno"</string>
    <string name="activity_resolver_set_always" msgid="4142825808921411476">"Nastavi na »vedno odpri«"</string>
    <string name="activity_resolver_use_once" msgid="948462794469672658">"Samo tokrat"</string>
    <string name="activity_resolver_app_settings" msgid="6758823206817748026">"Nastavitve"</string>
    <string name="activity_resolver_work_profiles_support" msgid="4071345609235361269">"%1$s ne podpira delovnega profila"</string>
    <string name="default_audio_route_name" product="tablet" msgid="367936735632195517">"Tablični računalnik"</string>
    <string name="default_audio_route_name" product="tv" msgid="4908971385068087367">"Televizor"</string>
    <string name="default_audio_route_name" product="default" msgid="9213546147739983977">"Telefon"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="1551166029093995289">"Zvočniki stojala"</string>
    <string name="default_audio_route_name_hdmi" msgid="5474470558160717850">"HDMI"</string>
    <string name="default_audio_route_name_headphones" msgid="6954070994792640762">"Slušalke"</string>
    <string name="default_audio_route_name_usb" msgid="895668743163316932">"USB"</string>
    <string name="default_audio_route_category_name" msgid="5241740395748134483">"Sistem"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="4214648773120426288">"Zvok prek Bluetootha"</string>
    <string name="wireless_display_route_description" msgid="8297563323032966831">"Brezžični prikaz"</string>
    <string name="media_route_button_content_description" msgid="2299223698196869956">"Predvajanje"</string>
    <string name="media_route_chooser_title" msgid="6646594924991269208">"Povezovanje z napravo"</string>
    <string name="media_route_chooser_title_for_remote_display" msgid="3105906508794326446">"Predvajanje zaslona v napravo"</string>
    <string name="media_route_chooser_searching" msgid="6119673534251329535">"Iskanje naprav …"</string>
    <string name="media_route_chooser_extended_settings" msgid="2506352159381327741">"Nastavitve"</string>
    <string name="media_route_controller_disconnect" msgid="7362617572732576959">"Prekinitev povezave"</string>
    <string name="media_route_status_scanning" msgid="8045156315309594482">"Pregledovanje ..."</string>
    <string name="media_route_status_connecting" msgid="5845597961412010540">"Vzpostavljanje povezave ..."</string>
    <string name="media_route_status_available" msgid="1477537663492007608">"Na voljo"</string>
    <string name="media_route_status_not_available" msgid="480912417977515261">"Ni na voljo"</string>
    <string name="media_route_status_in_use" msgid="6684112905244944724">"V uporabi"</string>
    <string name="display_manager_built_in_display_name" msgid="1015775198829722440">"Vgrajen zaslon"</string>
    <string name="display_manager_hdmi_display_name" msgid="1022758026251534975">"Zaslon HDMI"</string>
    <string name="display_manager_overlay_display_name" msgid="5306088205181005861">"Prekrivanje #<xliff:g id="ID">%1$d</xliff:g>"</string>
    <string name="display_manager_overlay_display_title" msgid="1480158037150469170">"<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> pik na palec"</string>
    <string name="display_manager_overlay_display_secure_suffix" msgid="2810034719482834679">", varen"</string>
    <string name="kg_forgot_pattern_button_text" msgid="406145459223122537">"Pozabljen vzorec"</string>
    <string name="kg_wrong_pattern" msgid="1342812634464179931">"Napačen vzorec"</string>
    <string name="kg_wrong_password" msgid="2384677900494439426">"Napačno geslo"</string>
    <string name="kg_wrong_pin" msgid="3680925703673166482">"Napačen PIN"</string>
    <plurals name="kg_too_many_failed_attempts_countdown" formatted="false" msgid="236717428673283568">
      <item quantity="one">Poskusite znova čez <xliff:g id="NUMBER">%d</xliff:g> sekundo.</item>
      <item quantity="two">Poskusite znova čez <xliff:g id="NUMBER">%d</xliff:g> sekundi.</item>
      <item quantity="few">Poskusite znova čez <xliff:g id="NUMBER">%d</xliff:g> sekunde.</item>
      <item quantity="other">Poskusite znova čez <xliff:g id="NUMBER">%d</xliff:g> sekund.</item>
    </plurals>
    <string name="kg_pattern_instructions" msgid="8366024510502517748">"Narišite vzorec"</string>
    <string name="kg_sim_pin_instructions" msgid="6479401489471690359">"Vnesite PIN za kartico SIM"</string>
    <string name="kg_pin_instructions" msgid="7355933174673539021">"Vnesite PIN"</string>
    <string name="kg_password_instructions" msgid="7179782578809398050">"Vnesite geslo"</string>
    <string name="kg_puk_enter_puk_hint" msgid="6696187482616360994">"Kartica SIM je onemogočena. Če želite nadaljevati, vnesite kodo PUK. Za dodatne informacije se obrnite na operaterja."</string>
    <string name="kg_puk_enter_pin_hint" msgid="8190982314659429770">"Vnesite želeno kodo PIN"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="6372557107414074580">"Potrdite želeno kodo PIN"</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8871937892678885545">"Odklepanje kartice SIM ..."</string>
    <string name="kg_password_wrong_pin_code" msgid="9013856346870572451">"Napačna koda PIN."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="4821601451222564077">"Vnesite PIN, ki vsebuje od štiri do osem številk."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="2539364558870734339">"Koda PUK mora biti 8-mestno število."</string>
    <string name="kg_invalid_puk" msgid="4809502818518963344">"Vnovič vnesite pravilno kodo PUK. Večkratni poskusi bodo trajno onemogočili kartico SIM."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="4705368340409816254">"Kodi PIN se ne ujemata"</string>
    <string name="kg_login_too_many_attempts" msgid="699292728290654121">"Preveč poskusov vzorca"</string>
    <string name="kg_login_instructions" msgid="3619844310339066827">"Če želite odkleniti napravo, se prijavite z Google Računom."</string>
    <string name="kg_login_username_hint" msgid="1765453775467133251">"Uporabniško ime (e-pošta)"</string>
    <string name="kg_login_password_hint" msgid="3330530727273164402">"Geslo"</string>
    <string name="kg_login_submit_button" msgid="893611277617096870">"Prijava"</string>
    <string name="kg_login_invalid_input" msgid="8292367491901220210">"Neveljavno uporabniško ime ali geslo."</string>
    <string name="kg_login_account_recovery_hint" msgid="4892466171043541248">"Ali ste pozabili uporabniško ime ali geslo?\nObiščite "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="kg_login_checking_password" msgid="4676010303243317253">"Preverjanje računa ..."</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="23741434207544038">"PIN ste <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat vnesli napačno. \n\nZnova poskusite čez <xliff:g id="NUMBER_1">%2$d</xliff:g> s."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="3328686432962224215">"Geslo ste <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat vnesli napačno. \n\nZnova poskusite čez <xliff:g id="NUMBER_1">%2$d</xliff:g> s."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="7357404233979139075">"Vzorec za odklepanje ste nepravilno narisali <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat. \n\nPoskusite znova čez <xliff:g id="NUMBER_1">%2$d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="3479940221343361587">"Tablični računalnik ste poskusili <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat napačno odkleniti. Če poskusite še <xliff:g id="NUMBER_1">%2$d</xliff:g>-krat in ne uspete, bo ponastavljen na privzete tovarniške nastavitve in vsi uporabniški podatki bodo izgubljeni."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tv" msgid="9064457748587850217">"Napravo Android TV ste neuspešno poskusili odkleniti <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat. Če poskusite še <xliff:g id="NUMBER_1">%2$d</xliff:g>-krat in ne uspete, bo naprava Android TV ponastavljena na privzete tovarniške nastavitve, vsi uporabniški podatki pa bodo izgubljeni."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="5955398963754432548">"Telefon ste poskusili <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat napačno odkleniti. Če poskusite še <xliff:g id="NUMBER_1">%2$d</xliff:g>-krat in ne uspete, bo ponastavljen na privzete tovarniške nastavitve in vsi uporabniški podatki bodo izgubljeni."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="2299099385175083308">"Tablični računalnik ste poskusili <xliff:g id="NUMBER">%d</xliff:g>-krat napačno odkleniti, zato bo ponastavljen na privzete tovarniške nastavitve."</string>
    <string name="kg_failed_attempts_now_wiping" product="tv" msgid="5045460916106267585">"Napravo Android TV ste neuspešno poskusili odkleniti <xliff:g id="NUMBER">%d</xliff:g>-krat. Naprava Android TV bo zdaj ponastavljena na privzete tovarniške nastavitve."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="5043730590446071189">"Telefon ste poskusili <xliff:g id="NUMBER">%d</xliff:g>-krat napačno odkleniti, zato bo ponastavljen na privzete tovarniške nastavitve."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="7086799295109717623">"Vzorec za odklepanje ste <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat napačno vnesli. Po nadaljnjih <xliff:g id="NUMBER_1">%2$d</xliff:g> neuspešnih poskusih boste pozvani, da tablični računalnik odklenete z e-poštnim računom.\n\nPoskusite znova čez <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tv" msgid="4670840383567106114">"Vzorec za odklepanje ste nepravilno narisali <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat. Če napravo Android TV neuspešno poskusite odkleniti še <xliff:g id="NUMBER_1">%2$d</xliff:g>-krat, jo boste morali odkleniti z e-poštnim računom.\n\n Poskusite znova čez <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="5270861875006378092">"Vzorec za odklepanje ste <xliff:g id="NUMBER_0">%1$d</xliff:g>-krat napačno vnesli. Po nadaljnjih <xliff:g id="NUMBER_1">%2$d</xliff:g> neuspešnih poskusih boste pozvani, da odklenete telefon z Googlovimi podatki za prijavo.\n\nPoskusite znova čez <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="kg_text_message_separator" product="default" msgid="4503708889934976866">" – "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="2034358143731750914">"Odstrani"</string>
    <string name="allow_while_in_use_permission_in_fgs" msgid="4101339676785053656">"V prihodnjih različicah R storitev v ospredju z zagonom iz ozadja iz paketa <xliff:g id="PACKAGENAME">%1$s</xliff:g> ne bo imela dovoljenja med uporabo aplikacije. Oglejte si go/r-bg-fgs-restriction in pošljite poročilo o napakah."</string>
    <string name="safe_media_volume_warning" product="default" msgid="3751676824423049994">"Ali želite povečati glasnost nad priporočeno raven?\n\nDolgotrajno poslušanje pri veliki glasnosti lahko poškoduje sluh."</string>
    <string name="accessibility_shortcut_warning_dialog_title" msgid="4017995837692622933">"Želite uporabljati bližnjico funkcij za ljudi s posebnimi potrebami?"</string>
    <string name="accessibility_shortcut_toogle_warning" msgid="4161716521310929544">"Ko je bližnjica vklopljena, pritisnite gumba za glasnost in ju pridržite tri sekunde, če želite zagnati funkcijo za ljudi s posebnimi potrebami."</string>
    <string name="accessibility_shortcut_multiple_service_warning_title" msgid="8417489297036013065">"Želite vklopiti funkcije za ljudi s posebnimi potrebami?"</string>
    <string name="accessibility_shortcut_multiple_service_warning" msgid="3740723309483706911">"Če za nekaj sekund pridržite obe tipki za glasnost, boste vklopili funkcije za ljudi s posebnimi potrebami. To lahko spremeni način delovanja naprave.\n\nTrenutne funkcije:\n<xliff:g id="SERVICE">%1$s</xliff:g>\nIzbrane funkcije lahko spremenite v meniju »Nastavitve« &gt; »Funkcije za ljudi s posebnimi potrebami«."</string>
    <string name="accessibility_shortcut_multiple_service_list" msgid="6935581470716541531">"	• <xliff:g id="SERVICE">%1$s</xliff:g>\n"</string>
    <string name="accessibility_shortcut_talkback_warning_title" msgid="3410100187167382427">"Želite vklopiti TalkBack?"</string>
    <string name="accessibility_shortcut_talkback_warning" msgid="8412954203626349109">"Če za nekaj sekund pridržite obe tipki za glasnost, boste vklopili bralnik zaslona TalkBack, ki pomaga slepim in slabovidnim osebam. TalkBack povsem spremeni način delovanja naprave.\n\nTo bližnjico lahko v meniju »Nastavitve« &gt; »Funkcije za ljudi s posebnimi potrebami« spremenite, da bo uporabljena za drugo funkcijo."</string>
    <string name="accessibility_shortcut_single_service_warning_title" msgid="2819109500943271385">"Želite vklopiti storitev <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_shortcut_single_service_warning" msgid="6363127705112844257">"Če za nekaj sekund pridržite obe tipki za glasnost, boste vklopili storitev <xliff:g id="SERVICE">%1$s</xliff:g>, ki je funkcija za ljudi s posebnimi potrebami. To lahko spremeni način delovanja naprave.\n\nTo bližnjico lahko v meniju »Nastavitve« &gt; »Funkcije za ljudi s posebnimi potrebami« spremenite, da bo uporabljena za drugo funkcijo."</string>
    <string name="accessibility_shortcut_on" msgid="5463618449556111344">"Vklopi"</string>
    <string name="accessibility_shortcut_off" msgid="3651336255403648739">"Ne vklopi"</string>
    <string name="accessibility_shortcut_menu_item_status_on" msgid="6608392117189732543">"VKLOPLJENO"</string>
    <string name="accessibility_shortcut_menu_item_status_off" msgid="5531598275559472393">"IZKLOPLJ."</string>
    <string name="accessibility_enable_service_title" msgid="3931558336268541484">"Ali storitvi <xliff:g id="SERVICE">%1$s</xliff:g> dovolite popoln nadzor nad svojo napravo?"</string>
    <string name="accessibility_enable_service_encryption_warning" msgid="8603532708618236909">"Če vklopite storitev <xliff:g id="SERVICE">%1$s</xliff:g>, vaša naprava ne bo uporabljala zaklepanja zaslona za izboljšanje šifriranja podatkov."</string>
    <string name="accessibility_service_warning_description" msgid="291674995220940133">"Popoln nadzor je ustrezen za aplikacije, ki vam pomagajo pri funkcijah za ljudi s posebnimi potrebami, vendar ne za večino aplikacij."</string>
    <string name="accessibility_service_screen_control_title" msgid="190017412626919776">"Ogledovanje in upravljanje zaslona"</string>
    <string name="accessibility_service_screen_control_description" msgid="6946315917771791525">"Bere lahko vso vsebino na zaslonu ter prikaže vsebino prek drugih aplikacij."</string>
    <string name="accessibility_service_action_perform_title" msgid="779670378951658160">"Ogledovanje in izvajanje dejanj"</string>
    <string name="accessibility_service_action_perform_description" msgid="2718852014003170558">"Spremlja lahko vaše interakcije z aplikacijo ali senzorjem strojne opreme ter komunicira z aplikacijami v vašem imenu."</string>
    <string name="accessibility_dialog_button_allow" msgid="2092558122987144530">"Dovoli"</string>
    <string name="accessibility_dialog_button_deny" msgid="4129575637812472671">"Zavrni"</string>
    <string name="accessibility_select_shortcut_menu_title" msgid="6002726538854613272">"Če želite začeti uporabljati funkcijo, se je dotaknite:"</string>
    <string name="accessibility_edit_shortcut_menu_button_title" msgid="239446795930436325">"Izberite funkcije, ki jih želite uporabljati z gumbom za funkcije za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_edit_shortcut_menu_volume_title" msgid="1077294237378645981">"Izberite funkcije, ki jih želite uporabljati z bližnjico na tipki za glasnost"</string>
    <string name="accessibility_uncheck_legacy_item_warning" msgid="8047830891064817447">"Storitev <xliff:g id="SERVICE_NAME">%s</xliff:g> je izklopljena"</string>
    <string name="edit_accessibility_shortcut_menu_button" msgid="8885752738733772935">"Uredi bližnjice"</string>
    <string name="done_accessibility_shortcut_menu_button" msgid="3668407723770815708">"Končano"</string>
    <string name="disable_accessibility_shortcut" msgid="5806091378745232383">"Izklopi bližnjico"</string>
    <string name="leave_accessibility_shortcut_on" msgid="6543362062336990814">"Uporabi bližnjico"</string>
    <string name="color_inversion_feature_name" msgid="326050048927789012">"Inverzija barv"</string>
    <string name="color_correction_feature_name" msgid="3655077237805422597">"Popravljanje barv"</string>
    <string name="accessibility_shortcut_enabling_service" msgid="5473495203759847687">"Tipki za glasnost sta pridržani. Storitev <xliff:g id="SERVICE_NAME">%1$s</xliff:g> je vklopljena."</string>
    <string name="accessibility_shortcut_disabling_service" msgid="8675244165062700619">"Tipki za glasnost sta pridržani. Storitev <xliff:g id="SERVICE_NAME">%1$s</xliff:g> je izklopljena."</string>
    <string name="accessibility_shortcut_spoken_feedback" msgid="4228997042855695090">"Za uporabo storitve <xliff:g id="SERVICE_NAME">%1$s</xliff:g> pritisnite obe tipki za glasnost in ju pridržite tri sekunde"</string>
    <string name="accessibility_button_prompt_text" msgid="8343213623338605305">"Izberite funkcijo, ki jo želite uporabljati, ko se dotaknete gumba za funkcije za ljudi s posebnimi potrebami:"</string>
    <string name="accessibility_gesture_prompt_text" msgid="8742535972130563952">"Izberite funkcijo, ki jo želite zagnati s potezo za ljudi s posebnimi potrebami (vlečenje z dvema prstoma z dna zaslona navzgor):"</string>
    <string name="accessibility_gesture_3finger_prompt_text" msgid="5211827854510660203">"Izberite funkcijo, ki jo želite zagnati s potezo za ljudi s posebnimi potrebami (vlečenje s tremi prsti z dna zaslona navzgor):"</string>
    <string name="accessibility_button_instructional_text" msgid="8853928358872550500">"Če želite preklopiti med funkcijami, pridržite gumb za funkcije za ljudi s posebnimi potrebami."</string>
    <string name="accessibility_gesture_instructional_text" msgid="9196230728837090497">"Če želite preklopiti med funkcijami, z dvema prstoma povlecite navzgor in pridržite."</string>
    <string name="accessibility_gesture_3finger_instructional_text" msgid="3425123684990193765">"Če želite preklopiti med funkcijami, s tremi prsti povlecite navzgor in pridržite."</string>
    <string name="accessibility_magnification_chooser_text" msgid="1502075582164931596">"Povečava"</string>
    <string name="user_switched" msgid="7249833311585228097">"Trenutni uporabnik <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="user_switching_message" msgid="1912993630661332336">"Preklop na uporabnika <xliff:g id="NAME">%1$s</xliff:g> …"</string>
    <string name="user_logging_out_message" msgid="7216437629179710359">"Odjavljanje uporabnika <xliff:g id="NAME">%1$s</xliff:g> …"</string>
    <string name="owner_name" msgid="8713560351570795743">"Lastnik"</string>
    <string name="error_message_title" msgid="4082495589294631966">"Napaka"</string>
    <string name="error_message_change_not_allowed" msgid="843159705042381454">"Skrbnik ne dovoli te spremembe"</string>
    <string name="app_not_found" msgid="3429506115332341800">"Najdena ni bila nobena aplikacija za izvedbo tega dejanja"</string>
    <string name="revoke" msgid="5526857743819590458">"Prekliči"</string>
    <string name="mediasize_iso_a0" msgid="7039061159929977973">"ISO A0"</string>
    <string name="mediasize_iso_a1" msgid="4063589931031977223">"ISO A1"</string>
    <string name="mediasize_iso_a2" msgid="2779860175680233980">"ISO A2"</string>
    <string name="mediasize_iso_a3" msgid="3683469257246970630">"ISO A3"</string>
    <string name="mediasize_iso_a4" msgid="752903572302658845">"ISO A4"</string>
    <string name="mediasize_iso_a5" msgid="3020439171949376572">"ISO A5"</string>
    <string name="mediasize_iso_a6" msgid="6503671662530738180">"ISO A6"</string>
    <string name="mediasize_iso_a7" msgid="8488649018955763878">"ISO A7"</string>
    <string name="mediasize_iso_a8" msgid="3380506944389571030">"ISO A8"</string>
    <string name="mediasize_iso_a9" msgid="7000627318995334730">"ISO A9"</string>
    <string name="mediasize_iso_a10" msgid="4091511972200388310">"ISO A10"</string>
    <string name="mediasize_iso_b0" msgid="2057859571254103889">"ISO B0"</string>
    <string name="mediasize_iso_b1" msgid="4931975244795236924">"ISO B1"</string>
    <string name="mediasize_iso_b2" msgid="4701978611340339483">"ISO B2"</string>
    <string name="mediasize_iso_b3" msgid="3509735449039761603">"ISO B3"</string>
    <string name="mediasize_iso_b4" msgid="486628178454656526">"ISO B4"</string>
    <string name="mediasize_iso_b5" msgid="2507554073053511267">"ISO B5"</string>
    <string name="mediasize_iso_b6" msgid="344189428571954711">"ISO B6"</string>
    <string name="mediasize_iso_b7" msgid="7266158663658064799">"ISO B7"</string>
    <string name="mediasize_iso_b8" msgid="5229204010533786299">"ISO B8"</string>
    <string name="mediasize_iso_b9" msgid="2925910409602493256">"ISO B9"</string>
    <string name="mediasize_iso_b10" msgid="8590530019536996218">"ISO B10"</string>
    <string name="mediasize_iso_c0" msgid="6504734131385460314">"ISO C0"</string>
    <string name="mediasize_iso_c1" msgid="1751671704929443684">"ISO C1"</string>
    <string name="mediasize_iso_c2" msgid="2935473413647925667">"ISO C2"</string>
    <string name="mediasize_iso_c3" msgid="6835637985527663396">"ISO C3"</string>
    <string name="mediasize_iso_c4" msgid="3000965043023118958">"ISO C4"</string>
    <string name="mediasize_iso_c5" msgid="3846339505379333795">"ISO C5"</string>
    <string name="mediasize_iso_c6" msgid="8663097559661858303">"ISO C6"</string>
    <string name="mediasize_iso_c7" msgid="4469290754678239705">"ISO C7"</string>
    <string name="mediasize_iso_c8" msgid="1949330679635319183">"ISO C8"</string>
    <string name="mediasize_iso_c9" msgid="3716843356839880581">"ISO C9"</string>
    <string name="mediasize_iso_c10" msgid="2113667674722450076">"ISO C10"</string>
    <string name="mediasize_na_letter" msgid="1947253006814499213">"Letter"</string>
    <string name="mediasize_na_gvrnmt_letter" msgid="4056220626420245955">"Government Letter"</string>
    <string name="mediasize_na_legal" msgid="8356233803828931150">"Legal"</string>
    <string name="mediasize_na_junior_legal" msgid="3398084874757748531">"Junior Legal"</string>
    <string name="mediasize_na_ledger" msgid="1819497882853940248">"Ledger"</string>
    <string name="mediasize_na_tabloid" msgid="6792611672983574375">"Tabloid"</string>
    <string name="mediasize_na_index_3x5" msgid="990821038991491710">"Index Card 3 x 5"</string>
    <string name="mediasize_na_index_4x6" msgid="4414381976602032401">"Index Card 4 x 6"</string>
    <string name="mediasize_na_index_5x8" msgid="4499341583361946948">"Index Card 5 x 8"</string>
    <string name="mediasize_na_monarch" msgid="4396943937986136896">"Monarch"</string>
    <string name="mediasize_na_quarto" msgid="2119101847712239885">"Quarto"</string>
    <string name="mediasize_na_foolscap" msgid="5011612828564394648">"Foolscap"</string>
    <string name="mediasize_chinese_roc_8k" msgid="411670106572707544">"ROC 8K"</string>
    <string name="mediasize_chinese_roc_16k" msgid="7496706798725321898">"ROC 16K"</string>
    <string name="mediasize_chinese_prc_1" msgid="946949835711037253">"PRC 1"</string>
    <string name="mediasize_chinese_prc_2" msgid="4704308592895046237">"PRC 2"</string>
    <string name="mediasize_chinese_prc_3" msgid="1082996050478581675">"PRC 3"</string>
    <string name="mediasize_chinese_prc_4" msgid="7865122849174932948">"PRC 4"</string>
    <string name="mediasize_chinese_prc_5" msgid="852020506971633186">"PRC 5"</string>
    <string name="mediasize_chinese_prc_6" msgid="3399567254628077606">"PRC 6"</string>
    <string name="mediasize_chinese_prc_7" msgid="2804330751361491000">"PRC 7"</string>
    <string name="mediasize_chinese_prc_8" msgid="7988760621340084314">"PRC 8"</string>
    <string name="mediasize_chinese_prc_9" msgid="90266288020939533">"PRC 9"</string>
    <string name="mediasize_chinese_prc_10" msgid="7721316829399772162">"PRC 10"</string>
    <string name="mediasize_chinese_prc_16k" msgid="7471455177845043180">"PRC 16K"</string>
    <string name="mediasize_chinese_om_pa_kai" msgid="6305242012782587594">"Pa Kai"</string>
    <string name="mediasize_chinese_om_dai_pa_kai" msgid="8133982147973309032">"Dai Pa Kai"</string>
    <string name="mediasize_chinese_om_jurro_ku_kai" msgid="5888548906612445289">"Jurro Ku Kai"</string>
    <string name="mediasize_japanese_jis_b10" msgid="6761433476186549691">"JIS B10"</string>
    <string name="mediasize_japanese_jis_b9" msgid="6011047111717561836">"JIS B9"</string>
    <string name="mediasize_japanese_jis_b8" msgid="1541865115368043069">"JIS B8"</string>
    <string name="mediasize_japanese_jis_b7" msgid="8300341273885698803">"JIS B7"</string>
    <string name="mediasize_japanese_jis_b6" msgid="4329528623016980657">"JIS B6"</string>
    <string name="mediasize_japanese_jis_b5" msgid="7340334955358311979">"JIS B5"</string>
    <string name="mediasize_japanese_jis_b4" msgid="7403538361394953235">"JIS B4"</string>
    <string name="mediasize_japanese_jis_b3" msgid="9024287678505132047">"JIS B3"</string>
    <string name="mediasize_japanese_jis_b2" msgid="5151340021154579154">"JIS B2"</string>
    <string name="mediasize_japanese_jis_b1" msgid="2709589944170908250">"JIS B1"</string>
    <string name="mediasize_japanese_jis_b0" msgid="1209735840926222618">"JIS B0"</string>
    <string name="mediasize_japanese_jis_exec" msgid="2137738196058117115">"JIS Exec"</string>
    <string name="mediasize_japanese_chou4" msgid="2533204016634398713">"Chou4"</string>
    <string name="mediasize_japanese_chou3" msgid="5976745918096025459">"Chou3"</string>
    <string name="mediasize_japanese_chou2" msgid="6841260581434101675">"Chou2"</string>
    <string name="mediasize_japanese_hagaki" msgid="2112968853810337326">"Hagaki"</string>
    <string name="mediasize_japanese_oufuku" msgid="1575013107082530108">"Oufuku"</string>
    <string name="mediasize_japanese_kahu" msgid="7290232592648122042">"Kahu"</string>
    <string name="mediasize_japanese_kaku2" msgid="7477551750461028312">"Kaku2"</string>
    <string name="mediasize_japanese_you4" msgid="5552111912684384833">"You4"</string>
    <string name="mediasize_unknown_portrait" msgid="3817016220446495613">"Neznano pokončno"</string>
    <string name="mediasize_unknown_landscape" msgid="1584741567225095325">"Neznano ležeče"</string>
    <string name="write_fail_reason_cancelled" msgid="2344081488493969190">"Preklicano"</string>
    <string name="write_fail_reason_cannot_write" msgid="432118118378451508">"Napaka pri pisanju vsebine"</string>
    <string name="reason_unknown" msgid="5599739807581133337">"neznano"</string>
    <string name="reason_service_unavailable" msgid="5288405248063804713">"Tiskalna storitev ni omogočena"</string>
    <string name="print_service_installed_title" msgid="6134880817336942482">"Storitev <xliff:g id="NAME">%s</xliff:g> je nameščena"</string>
    <string name="print_service_installed_message" msgid="7005672469916968131">"Če želite omogočiti, se dotaknite"</string>
    <string name="restr_pin_enter_admin_pin" msgid="1199419462726962697">"Vnos skrbniške kode PIN"</string>
    <string name="restr_pin_enter_pin" msgid="373139384161304555">"Vnesite PIN"</string>
    <string name="restr_pin_incorrect" msgid="3861383632940852496">"Napačno"</string>
    <string name="restr_pin_enter_old_pin" msgid="7537079094090650967">"Trenutni PIN"</string>
    <string name="restr_pin_enter_new_pin" msgid="3267614461844565431">"Novi PIN"</string>
    <string name="restr_pin_confirm_pin" msgid="7143161971614944989">"Potrdite novi PIN"</string>
    <string name="restr_pin_create_pin" msgid="917067613896366033">"Ustvarite PIN za spreminjanje omejitev"</string>
    <string name="restr_pin_error_doesnt_match" msgid="7063392698489280556">"Kodi PIN se ne ujemata. Poskusite znova."</string>
    <string name="restr_pin_error_too_short" msgid="1547007808237941065">"PIN je prekratek. Imeti mora vsaj 4 števke."</string>
    <plurals name="restr_pin_countdown" formatted="false" msgid="4427486903285216153">
      <item quantity="one">Poskusite znova čez <xliff:g id="COUNT">%d</xliff:g> sekundo</item>
      <item quantity="two">Poskusite znova čez <xliff:g id="COUNT">%d</xliff:g> sekundi</item>
      <item quantity="few">Poskusite znova čez <xliff:g id="COUNT">%d</xliff:g> sekunde</item>
      <item quantity="other">Poskusite znova čez <xliff:g id="COUNT">%d</xliff:g> sekund</item>
    </plurals>
    <string name="restr_pin_try_later" msgid="5897719962541636727">"Poskusite znova pozneje"</string>
    <string name="immersive_cling_title" msgid="2307034298721541791">"Vklopljen je celozaslonski način"</string>
    <string name="immersive_cling_description" msgid="7092737175345204832">"Zaprete ga tako, da z vrha s prstom povlečete navzdol."</string>
    <string name="immersive_cling_positive" msgid="7047498036346489883">"Razumem"</string>
    <string name="done_label" msgid="7283767013231718521">"Dokončano"</string>
    <string name="hour_picker_description" msgid="5153757582093524635">"Okrogli drsnik za ure"</string>
    <string name="minute_picker_description" msgid="9029797023621927294">"Okrogli drsnik za minute"</string>
    <string name="select_hours" msgid="5982889657313147347">"Izberite ure"</string>
    <string name="select_minutes" msgid="9157401137441014032">"Izberite minute"</string>
    <string name="select_day" msgid="2060371240117403147">"Izberite mesec in dan"</string>
    <string name="select_year" msgid="1868350712095595393">"Izberite leto"</string>
    <string name="deleted_key" msgid="9130083334943364001">"Številka <xliff:g id="KEY">%1$s</xliff:g> je izbrisana"</string>
    <string name="managed_profile_label_badge" msgid="6762559569999499495">"<xliff:g id="LABEL">%1$s</xliff:g> za delo"</string>
    <string name="managed_profile_label_badge_2" msgid="5673187309555352550">"2. službeni <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="managed_profile_label_badge_3" msgid="6882151970556391957">"3. službeni <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="lock_to_app_unlock_pin" msgid="3890940811866290782">"Zahtevaj PIN pred odpenjanjem"</string>
    <string name="lock_to_app_unlock_pattern" msgid="2694204070499712503">"Pred odpenjanjem vprašaj za vzorec za odklepanje"</string>
    <string name="lock_to_app_unlock_password" msgid="9126722403506560473">"Pred odpenjanjem vprašaj za geslo"</string>
    <string name="package_installed_device_owner" msgid="7035926868974878525">"Namestil skrbnik"</string>
    <string name="package_updated_device_owner" msgid="7560272363805506941">"Posodobil skrbnik"</string>
    <string name="package_deleted_device_owner" msgid="2292335928930293023">"Izbrisal skrbnik"</string>
    <string name="confirm_battery_saver" msgid="5247976246208245754">"V redu"</string>
    <string name="battery_saver_description_with_learn_more" msgid="5997766757551917769">"Funkcija varčevanja z energijo baterije podaljša čas delovanja baterije tako:\n\n•Vklopi temno temo,\n•izklopi ali omeji izvajanje dejavnosti v ozadju, nekaterih vizualnih učinkov in drugih funkcij, kot je »Hey Google«.\n\n"<annotation id="url">"Več o tem"</annotation></string>
    <string name="battery_saver_description" msgid="8587408568232177204">"Funkcija varčevanja z energijo baterije podaljša čas delovanja baterije tako:\n\n•Vklopi temno temo,\n•izklopi ali omeji izvajanje dejavnosti v ozadju, nekaterih vizualnih učinkov in drugih funkcij, kot je »Hey Google«."</string>
    <string name="data_saver_description" msgid="4995164271550590517">"Zaradi zmanjševanja prenesene količine podatkov funkcija varčevanja s podatki nekaterim aplikacijam preprečuje, da bi v ozadju pošiljale ali prejemale podatke. Aplikacija, ki jo trenutno uporabljate, lahko prenaša podatke, vendar to morda počne manj pogosto. To na primer pomeni, da se slike ne prikažejo, dokler se jih ne dotaknete."</string>
    <string name="data_saver_enable_title" msgid="7080620065745260137">"Vklop varčevanja s podatki?"</string>
    <string name="data_saver_enable_button" msgid="4399405762586419726">"Vklop"</string>
    <plurals name="zen_mode_duration_minutes_summary" formatted="false" msgid="2877101784123058273">
      <item quantity="one">%d minuto (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="two">%d minuti (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">%d minute (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%d minut (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_summary_short" formatted="false" msgid="4230730310318858312">
      <item quantity="one">%1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="two">%1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">%1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary" formatted="false" msgid="7725354244196466758">
      <item quantity="one">Za %1$d uro (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="two">Za %1$d uri (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">Za %1$d ure (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Za %1$d ur (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary_short" formatted="false" msgid="588719069121765642">
      <item quantity="one">%1$d h (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="two">%1$d h (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">%1$d h (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d h (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes" formatted="false" msgid="1148568456958944998">
      <item quantity="one">%d minuto</item>
      <item quantity="two">%d minuti</item>
      <item quantity="few">%d minute</item>
      <item quantity="other">%d minut</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_short" formatted="false" msgid="2742377799995454859">
      <item quantity="one">%d min</item>
      <item quantity="two">%d min</item>
      <item quantity="few">%d min</item>
      <item quantity="other">%d min</item>
    </plurals>
    <plurals name="zen_mode_duration_hours" formatted="false" msgid="525401855645490022">
      <item quantity="one">Za %d uro</item>
      <item quantity="two">Za %d uri</item>
      <item quantity="few">Za %d ure</item>
      <item quantity="other">Za %d ur</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_short" formatted="false" msgid="7644653189680911640">
      <item quantity="one">%d h</item>
      <item quantity="two">%d h</item>
      <item quantity="few">%d h</item>
      <item quantity="other">%d h</item>
    </plurals>
    <string name="zen_mode_until" msgid="2250286190237669079">"Do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_alarm" msgid="7046911727540499275">"Do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g> (naslednji alarm)"</string>
    <string name="zen_mode_forever" msgid="740585666364912448">"Dokler ne izklopite"</string>
    <string name="zen_mode_forever_dnd" msgid="3423201955704180067">"Dokler ne izklopite načina »ne moti«"</string>
    <string name="zen_mode_rule_name_combination" msgid="7174598364351313725">"<xliff:g id="FIRST">%1$s</xliff:g>/<xliff:g id="REST">%2$s</xliff:g>"</string>
    <string name="toolbar_collapse_description" msgid="8009920446193610996">"Strni"</string>
    <string name="zen_mode_feature_name" msgid="3785547207263754500">"Ne moti"</string>
    <string name="zen_mode_downtime_feature_name" msgid="5886005761431427128">"Čas nedelovanja"</string>
    <string name="zen_mode_default_weeknights_name" msgid="7902108149994062847">"Noč med tednom"</string>
    <string name="zen_mode_default_weekends_name" msgid="4707200272709377930">"Konec tedna"</string>
    <string name="zen_mode_default_events_name" msgid="2280682960128512257">"Dogodek"</string>
    <string name="zen_mode_default_every_night_name" msgid="1467765312174275823">"Spanje"</string>
    <string name="muted_by" msgid="91464083490094950">"<xliff:g id="THIRD_PARTY">%1$s</xliff:g> izklaplja nekatere zvoke"</string>
    <string name="system_error_wipe_data" msgid="5910572292172208493">"Vaša naprava ima notranjo napako in bo morda nestabilna, dokler je ne ponastavite na tovarniške nastavitve."</string>
    <string name="system_error_manufacturer" msgid="703545241070116315">"Vaša naprava ima notranjo napako. Če želite več informacij, se obrnite na proizvajalca."</string>
    <string name="stk_cc_ussd_to_dial" msgid="3139884150741157610">"Zahteva USSD je spremenjena v navaden klic"</string>
    <string name="stk_cc_ussd_to_ss" msgid="4826846653052609738">"Zahteva USSD je spremenjena v zahtevo SS"</string>
    <string name="stk_cc_ussd_to_ussd" msgid="8343001461299302472">"Spremenjeno v novo zahtevo USSD"</string>
    <string name="stk_cc_ussd_to_dial_video" msgid="429118590323618623">"Zahteva USSD je spremenjena v videoklic"</string>
    <string name="stk_cc_ss_to_dial" msgid="4087396658768717077">"Zahteva SS je spremenjena v navaden klic"</string>
    <string name="stk_cc_ss_to_dial_video" msgid="1324194624384312664">"Zahteva SS je spremenjena v videoklic"</string>
    <string name="stk_cc_ss_to_ussd" msgid="8417905193112944760">"Zahteva SS je spremenjena v zahtevo USSD"</string>
    <string name="stk_cc_ss_to_ss" msgid="132040645206514450">"Spremenjeno v novo zahtevo SS"</string>
    <string name="notification_work_profile_content_description" msgid="5296477955677725799">"Delovni profil"</string>
    <string name="notification_alerted_content_description" msgid="6139691253611265992">"Opozorilo prikazano"</string>
    <string name="expand_button_content_description_collapsed" msgid="3873368935659010279">"Razširi"</string>
    <string name="expand_button_content_description_expanded" msgid="7484217944948667489">"Strni"</string>
    <string name="expand_action_accessibility" msgid="1947657036871746627">"preklop razširitve"</string>
    <string name="usb_midi_peripheral_name" msgid="490523464968655741">"Vrata USB za dodatno opremo za Android"</string>
    <string name="usb_midi_peripheral_manufacturer_name" msgid="7557148557088787741">"Android"</string>
    <string name="usb_midi_peripheral_product_name" msgid="2836276258480904434">"Vrata USB za dodatno opremo"</string>
    <string name="floating_toolbar_open_overflow_description" msgid="2260297653578167367">"Več možnosti"</string>
    <string name="floating_toolbar_close_overflow_description" msgid="3949818077708138098">"Zapri presežni element"</string>
    <string name="maximize_button_text" msgid="4258922519914732645">"Maksimiziraj"</string>
    <string name="close_button_text" msgid="10603510034455258">"Zapri"</string>
    <string name="notification_messaging_title_template" msgid="772857526770251989">"<xliff:g id="CONVERSATION_TITLE">%1$s</xliff:g>: <xliff:g id="SENDER_NAME">%2$s</xliff:g>"</string>
    <plurals name="selected_count" formatted="false" msgid="3946212171128200491">
      <item quantity="one"><xliff:g id="COUNT_1">%1$d</xliff:g> izbran</item>
      <item quantity="two"><xliff:g id="COUNT_1">%1$d</xliff:g> izbrana</item>
      <item quantity="few"><xliff:g id="COUNT_1">%1$d</xliff:g> izbrani</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> izbranih</item>
    </plurals>
    <string name="default_notification_channel_label" msgid="3697928973567217330">"Nekategorizirano"</string>
    <string name="importance_from_user" msgid="2782756722448800447">"Vi določite raven pomembnosti teh obvestil."</string>
    <string name="importance_from_person" msgid="4235804979664465383">"Pomembno zaradi udeleženih ljudi."</string>
    <string name="notification_history_title_placeholder" msgid="7748630986182249599">"Obvestilo po meri iz aplikacije"</string>
    <string name="user_creation_account_exists" msgid="2239146360099708035">"Ali aplikaciji <xliff:g id="APP">%1$s</xliff:g> dovolite, da ustvari novega uporabnika za račun <xliff:g id="ACCOUNT">%2$s</xliff:g> (uporabnik s tem računom že obstaja)?"</string>
    <string name="user_creation_adding" msgid="7305185499667958364">"Ali aplikaciji <xliff:g id="APP">%1$s</xliff:g> dovolite, da ustvari novega uporabnika za račun <xliff:g id="ACCOUNT">%2$s</xliff:g>?"</string>
    <string name="language_selection_title" msgid="52674936078683285">"Dodajanje jezika"</string>
    <string name="country_selection_title" msgid="5221495687299014379">"Nastavitev območja"</string>
    <string name="search_language_hint" msgid="7004225294308793583">"Vnesite ime jezika"</string>
    <string name="language_picker_section_suggested" msgid="6556199184638990447">"Predlagano"</string>
    <string name="language_picker_section_all" msgid="1985809075777564284">"Vsi jeziki"</string>
    <string name="region_picker_section_all" msgid="756441309928774155">"Vse regije"</string>
    <string name="locale_search_menu" msgid="6258090710176422934">"Išči"</string>
    <string name="app_suspended_title" msgid="888873445010322650">"Aplikacija ni na voljo"</string>
    <string name="app_suspended_default_message" msgid="6451215678552004172">"Aplikacija <xliff:g id="APP_NAME_0">%1$s</xliff:g> trenutno ni na voljo. To upravlja aplikacija <xliff:g id="APP_NAME_1">%2$s</xliff:g>."</string>
    <string name="app_suspended_more_details" msgid="211260942831587014">"Več o tem"</string>
    <string name="app_suspended_unsuspend_message" msgid="1665438589450555459">"Prekliči začasno zaustavitev aplikacije"</string>
    <string name="work_mode_off_title" msgid="5503291976647976560">"Želite vklopiti delovni profil?"</string>
    <string name="work_mode_off_message" msgid="8417484421098563803">"Vklopili boste svoje delovne aplikacije, obvestila, podatke in druge funkcije delovnega profila"</string>
    <string name="work_mode_turn_on" msgid="3662561662475962285">"Vklop"</string>
    <string name="app_blocked_title" msgid="7353262160455028160">"Aplikacija ni na voljo"</string>
    <string name="app_blocked_message" msgid="542972921087873023">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> trenutno ni na voljo."</string>
    <string name="deprecated_target_sdk_message" msgid="5203207875657579953">"Ta aplikacija je bila zasnovana za starejšo različico Androida in morda ne bo delovala pravilno. Preverite, ali so na voljo posodobitve, ali pa se obrnite na razvijalca."</string>
    <string name="deprecated_target_sdk_app_store" msgid="8456784048558808909">"Preveri, ali je na voljo posodobitev"</string>
    <string name="new_sms_notification_title" msgid="6528758221319927107">"Imate nova sporočila."</string>
    <string name="new_sms_notification_content" msgid="3197949934153460639">"Za ogled odprite aplikacijo za SMS-je"</string>
    <string name="profile_encrypted_title" msgid="9001208667521266472">"Nekatere funkcije bodo morda omejene"</string>
    <string name="profile_encrypted_detail" msgid="5279730442756849055">"Delovni profil je zaklenjen"</string>
    <string name="profile_encrypted_message" msgid="1128512616293157802">"Dotaknite se za odkl. del. pr."</string>
    <string name="usb_mtp_launch_notification_title" msgid="774319638256707227">"Vzpostavljena povezava z napravo <xliff:g id="PRODUCT_NAME">%1$s</xliff:g>"</string>
    <string name="usb_mtp_launch_notification_description" msgid="6942535713629852684">"Dotaknite se, če si želite ogledati datoteke"</string>
    <string name="pin_target" msgid="8036028973110156895">"Pripenjanje"</string>
    <string name="pin_specific_target" msgid="7824671240625957415">"Pripni aplikacijo <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="unpin_target" msgid="3963318576590204447">"Odpenjanje"</string>
    <string name="unpin_specific_target" msgid="3859828252160908146">"Odpni aplikacijo <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="app_info" msgid="6113278084877079851">"Podatki o aplikacijah"</string>
    <string name="negative_duration" msgid="1938335096972945232">"−<xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="demo_starting_message" msgid="6577581216125805905">"Začenjanje predstavitve …"</string>
    <string name="demo_restarting_message" msgid="1160053183701746766">"Ponastavljanje naprave …"</string>
    <string name="suspended_widget_accessibility" msgid="6331451091851326101">"<xliff:g id="LABEL">%1$s</xliff:g> – onemogočeno"</string>
    <string name="conference_call" msgid="5731633152336490471">"Konferenčni klic"</string>
    <string name="tooltip_popup_title" msgid="7863719020269945722">"Opis orodja"</string>
    <string name="app_category_game" msgid="4534216074910244790">"Igre"</string>
    <string name="app_category_audio" msgid="8296029904794676222">"Glasba in zvok"</string>
    <string name="app_category_video" msgid="2590183854839565814">"Filmi in videoposnetki"</string>
    <string name="app_category_image" msgid="7307840291864213007">"Fotografije in slike"</string>
    <string name="app_category_social" msgid="2278269325488344054">"Druženje in komuniciranje"</string>
    <string name="app_category_news" msgid="1172762719574964544">"Novice in revije"</string>
    <string name="app_category_maps" msgid="6395725487922533156">"Zemljevidi in navigacija"</string>
    <string name="app_category_productivity" msgid="1844422703029557883">"Storilnost"</string>
    <string name="device_storage_monitor_notification_channel" msgid="5164244565844470758">"Shramba naprave"</string>
    <string name="adb_debugging_notification_channel_tv" msgid="4764046459631031496">"Odpravljanje težav prek povezave USB"</string>
    <string name="time_picker_hour_label" msgid="4208590187662336864">"ura"</string>
    <string name="time_picker_minute_label" msgid="8307452311269824553">"minute"</string>
    <string name="time_picker_header_text" msgid="9073802285051516688">"Nastavitev ure"</string>
    <string name="time_picker_input_error" msgid="8386271930742451034">"Vnesite veljaven čas"</string>
    <string name="time_picker_prompt_label" msgid="303588544656363889">"Vnesite uro"</string>
    <string name="time_picker_text_input_mode_description" msgid="4761160667516611576">"Preklopite na način za vnašanje besedila, da vnesete čas."</string>
    <string name="time_picker_radial_mode_description" msgid="1222342577115016953">"Preklopite na način ure, da vnesete čas."</string>
    <string name="autofill_picker_accessibility_title" msgid="4425806874792196599">"Možnosti samodejnega izpolnjevanja"</string>
    <string name="autofill_save_accessibility_title" msgid="1523225776218450005">"Shranjevanje v storitev samodejnega izpolnjevanja"</string>
    <string name="autofill_error_cannot_autofill" msgid="6528827648643138596">"Vsebine ni mogoče samodejno izpolniti"</string>
    <string name="autofill_picker_no_suggestions" msgid="1076022650427481509">"Ni predlogov za samodejno izpolnjevanje"</string>
    <plurals name="autofill_picker_some_suggestions" formatted="false" msgid="6651883186966959978">
      <item quantity="one"><xliff:g id="COUNT">%1$s</xliff:g> predlog za samodejno izpolnjevanje</item>
      <item quantity="two"><xliff:g id="COUNT">%1$s</xliff:g> predloga za samodejno izpolnjevanje</item>
      <item quantity="few"><xliff:g id="COUNT">%1$s</xliff:g> predlogi za samodejno izpolnjevanje</item>
      <item quantity="other"><xliff:g id="COUNT">%1$s</xliff:g> predlogov za samodejno izpolnjevanje</item>
    </plurals>
    <string name="autofill_save_title" msgid="7719802414283739775">"Želite shraniti v aplikacijo "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_type" msgid="3002460014579799605">"Želite shraniti element <xliff:g id="TYPE">%1$s</xliff:g> v aplikacijo "<b>"<xliff:g id="LABEL">%2$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_2types" msgid="3783270967447869241">"Želite shraniti elementa <xliff:g id="TYPE_0">%1$s</xliff:g> in <xliff:g id="TYPE_1">%2$s</xliff:g> v aplikacijo "<b>"<xliff:g id="LABEL">%3$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_3types" msgid="6598228952100102578">"Želite shraniti elemente <xliff:g id="TYPE_0">%1$s</xliff:g>, <xliff:g id="TYPE_1">%2$s</xliff:g> in <xliff:g id="TYPE_2">%3$s</xliff:g> v aplikacijo "<b>"<xliff:g id="LABEL">%4$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title" msgid="3630695947047069136">"Želite posodobiti v aplikaciji "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_type" msgid="5264152633488495704">"Želite posodobiti element <xliff:g id="TYPE">%1$s</xliff:g> v aplikaciji "<b>"<xliff:g id="LABEL">%2$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_2types" msgid="1797514386321086273">"Želite posodobiti elementa <xliff:g id="TYPE_0">%1$s</xliff:g> in <xliff:g id="TYPE_1">%2$s</xliff:g> v aplikaciji "<b>"<xliff:g id="LABEL">%3$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_3types" msgid="1312232153076212291">"Želite posodobiti te elemente v aplikaciji "<b>"<xliff:g id="LABEL">%4$s</xliff:g>"</b>": <xliff:g id="TYPE_0">%1$s</xliff:g>, <xliff:g id="TYPE_1">%2$s</xliff:g> in <xliff:g id="TYPE_2">%3$s</xliff:g>?"</string>
    <string name="autofill_save_yes" msgid="8035743017382012850">"Shrani"</string>
    <string name="autofill_save_no" msgid="9212826374207023544">"Ne, hvala"</string>
    <string name="autofill_save_notnow" msgid="2853932672029024195">"Ne zdaj"</string>
    <string name="autofill_save_never" msgid="6821841919831402526">"Nikoli"</string>
    <string name="autofill_update_yes" msgid="4608662968996874445">"Posodobi"</string>
    <string name="autofill_continue_yes" msgid="7914985605534510385">"Naprej"</string>
    <string name="autofill_save_type_password" msgid="5624528786144539944">"geslo"</string>
    <string name="autofill_save_type_address" msgid="3111006395818252885">"naslov"</string>
    <string name="autofill_save_type_credit_card" msgid="3583795235862046693">"kreditno kartico"</string>
    <string name="autofill_save_type_debit_card" msgid="3169397504133097468">"debetna kartica"</string>
    <string name="autofill_save_type_payment_card" msgid="6555012156728690856">"plačilna kartica"</string>
    <string name="autofill_save_type_generic_card" msgid="1019367283921448608">"kartica"</string>
    <string name="autofill_save_type_username" msgid="1018816929884640882">"uporabniško ime"</string>
    <string name="autofill_save_type_email_address" msgid="1303262336895591924">"e-poštni naslov"</string>
    <string name="etws_primary_default_message_earthquake" msgid="8401079517718280669">"Ostanite mirni in poiščite zavetje v bližini."</string>
    <string name="etws_primary_default_message_tsunami" msgid="5828171463387976279">"Takoj se umaknite z obalnih območij in bregov rek na varnejše mesto, na primer na višje ležeča mesta."</string>
    <string name="etws_primary_default_message_earthquake_and_tsunami" msgid="4888224011071875068">"Ostanite mirni in poiščite zavetje v bližini."</string>
    <string name="etws_primary_default_message_test" msgid="4583367373909549421">"Preskus sporočil v sili"</string>
    <string name="notification_reply_button_accessibility" msgid="5235776156579456126">"Odgovor"</string>
    <string name="etws_primary_default_message_others" msgid="7958161706019130739"></string>
    <string name="mmcc_authentication_reject" msgid="4891965994643876369">"Kartica SIM ne dovoljuje glasovnih klicev"</string>
    <string name="mmcc_imsi_unknown_in_hlr" msgid="227760698553988751">"Kartica SIM ne omogoča opravljanja glasovnih klicev"</string>
    <string name="mmcc_illegal_ms" msgid="7509650265233909445">"Kartica SIM ne dovoljuje glasovnih klicev"</string>
    <string name="mmcc_illegal_me" msgid="6505557881889904915">"Telefon ne dovoljuje glasovnih klicev"</string>
    <string name="mmcc_authentication_reject_msim_template" msgid="4480853038909922153">"Kartica SIM <xliff:g id="SIMNUMBER">%d</xliff:g> ni dovoljena"</string>
    <string name="mmcc_imsi_unknown_in_hlr_msim_template" msgid="3688508325248599657">"Kartica SIM <xliff:g id="SIMNUMBER">%d</xliff:g> ni omogočena za uporabo"</string>
    <string name="mmcc_illegal_ms_msim_template" msgid="832644375774599327">"Kartica SIM <xliff:g id="SIMNUMBER">%d</xliff:g> ni dovoljena"</string>
    <string name="mmcc_illegal_me_msim_template" msgid="4802735138861422802">"Kartica SIM <xliff:g id="SIMNUMBER">%d</xliff:g> ni dovoljena"</string>
    <string name="popup_window_default_title" msgid="6907717596694826919">"Pojavno okno"</string>
    <string name="slice_more_content" msgid="3377367737876888459">"in še <xliff:g id="NUMBER">%1$d</xliff:g>"</string>
    <string name="shortcut_restored_on_lower_version" msgid="9206301954024286063">"Zdaj imate prejšnjo različico aplikacije ali različico, ki ni združljiva s to bližnjico"</string>
    <string name="shortcut_restore_not_supported" msgid="4763198938588468400">"Bližnjice ni bilo mogoče obnoviti, ker aplikacija ne podpira varnostnega kopiranja in obnavljanja"</string>
    <string name="shortcut_restore_signature_mismatch" msgid="579345304221605479">"Bližnjice ni bilo mogoče obnoviti zaradi neujemanja podpisa aplikacije"</string>
    <string name="shortcut_restore_unknown_issue" msgid="2478146134395982154">"Bližnjice ni bilo mogoče obnoviti"</string>
    <string name="shortcut_disabled_reason_unknown" msgid="753074793553599166">"Bližnjica je onemogočena"</string>
    <string name="harmful_app_warning_uninstall" msgid="6472912975664191772">"ODMESTI"</string>
    <string name="harmful_app_warning_open_anyway" msgid="5963657791740211807">"VSEENO ODPRI"</string>
    <string name="harmful_app_warning_title" msgid="8794823880881113856">"Zaznana je bila škodljiva aplikacija"</string>
    <string name="slices_permission_request" msgid="3677129866636153406">"Aplikacija <xliff:g id="APP_0">%1$s</xliff:g> želi prikazati izreze aplikacije <xliff:g id="APP_2">%2$s</xliff:g>"</string>
    <string name="screenshot_edit" msgid="7408934887203689207">"Urejanje"</string>
    <string name="volume_dialog_ringer_guidance_vibrate" msgid="2055927873175228519">"Vibriranje bo vklopljeno za klice in obvestila"</string>
    <string name="volume_dialog_ringer_guidance_silent" msgid="1011246774949993783">"Zvonjenje bo izklopljeno za klice in obvestila"</string>
    <string name="notification_channel_system_changes" msgid="2462010596920209678">"Sistemske spremembe"</string>
    <string name="notification_channel_do_not_disturb" msgid="7832584281883687653">"Ne moti"</string>
    <string name="zen_upgrade_notification_visd_title" msgid="2001148984371968620">"Novi način »ne moti« skriva obvestila"</string>
    <string name="zen_upgrade_notification_visd_content" msgid="3683314609114134946">"Dotaknite se, če želite izvedeti več in spremeniti."</string>
    <string name="zen_upgrade_notification_title" msgid="8198167698095298717">"Način »ne moti« je spremenjen"</string>
    <string name="zen_upgrade_notification_content" msgid="5228458567180124005">"Dotaknite se, da preverite, kaj je blokirano."</string>
    <string name="notification_app_name_system" msgid="3045196791746735601">"Sistem"</string>
    <string name="notification_app_name_settings" msgid="9088548800899952531">"Nastavitve"</string>
    <string name="notification_appops_camera_active" msgid="8177643089272352083">"Fotoaparat"</string>
    <string name="notification_appops_microphone_active" msgid="581333393214739332">"Mikrofon"</string>
    <string name="notification_appops_overlay_active" msgid="5571732753262836481">"prekriva druge aplikacije na zaslonu"</string>
    <string name="dynamic_mode_notification_channel_name" msgid="2986926422100223328">"Rutinsko informativno obvestilo o načinu delovanja"</string>
    <string name="dynamic_mode_notification_title" msgid="9205715501274608016">"Baterija se bo morda izpraznila, preden jo običajno priključite na polnjenje"</string>
    <string name="dynamic_mode_notification_summary" msgid="4141614604437372157">"Vklopilo se je varčevanje z energijo baterije za podaljšanje časa delovanja baterije"</string>
    <string name="battery_saver_notification_channel_name" msgid="3918243458067916913">"Varčevanje z energijo baterije"</string>
    <string name="battery_saver_off_notification_title" msgid="7637255960468032515">"Varčevanje z energijo baterije je izklopljeno"</string>
    <string name="battery_saver_charged_notification_summary" product="default" msgid="5544457317418624367">"Baterija v telefonu je dovolj napolnjena. Funkcije niso več omejene."</string>
    <string name="battery_saver_charged_notification_summary" product="tablet" msgid="4426317048139996888">"Baterija v tabličnem računalniku je dovolj napolnjena. Funkcije niso več omejene."</string>
    <string name="battery_saver_charged_notification_summary" product="device" msgid="1031562417867646649">"Baterija v napravi je dovolj napolnjena. Funkcije niso več omejene."</string>
    <string name="mime_type_folder" msgid="2203536499348787650">"Mapa"</string>
    <string name="mime_type_apk" msgid="3168784749499623902">"Aplikacija za Android"</string>
    <string name="mime_type_generic" msgid="4606589110116560228">"Datoteka"</string>
    <string name="mime_type_generic_ext" msgid="9220220924380909486">"Datoteka <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_audio" msgid="4933450584432509875">"Zvočna datoteka"</string>
    <string name="mime_type_audio_ext" msgid="2615491023840514797">"Zvočna datoteka <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_video" msgid="7071965726609428150">"Videoposnetek"</string>
    <string name="mime_type_video_ext" msgid="185438149044230136">"Videoposnetek <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_image" msgid="2134307276151645257">"Slika"</string>
    <string name="mime_type_image_ext" msgid="5743552697560999471">"Slika <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_compressed" msgid="8737300936080662063">"Arhiv"</string>
    <string name="mime_type_compressed_ext" msgid="4775627287994475737">"Arhivska datoteka <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_document" msgid="3737256839487088554">"Dokument"</string>
    <string name="mime_type_document_ext" msgid="2398002765046677311">"Dokument <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_spreadsheet" msgid="8188407519131275838">"Preglednica"</string>
    <string name="mime_type_spreadsheet_ext" msgid="8720173181137254414">"Preglednica <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_presentation" msgid="1145384236788242075">"Predstavitev"</string>
    <string name="mime_type_presentation_ext" msgid="8761049335564371468">"Predstavitev <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="bluetooth_airplane_mode_toast" msgid="2066399056595768554">"Bluetooth bo v načinu za letalo ostal vklopljen"</string>
    <string name="car_loading_profile" msgid="8219978381196748070">"Nalaganje"</string>
    <plurals name="file_count" formatted="false" msgid="7063513834724389247">
      <item quantity="one"><xliff:g id="FILE_NAME_2">%s</xliff:g> in še <xliff:g id="COUNT_3">%d</xliff:g> datoteka</item>
      <item quantity="two"><xliff:g id="FILE_NAME_2">%s</xliff:g> in še <xliff:g id="COUNT_3">%d</xliff:g> datoteki</item>
      <item quantity="few"><xliff:g id="FILE_NAME_2">%s</xliff:g> in še <xliff:g id="COUNT_3">%d</xliff:g> datoteke</item>
      <item quantity="other"><xliff:g id="FILE_NAME_2">%s</xliff:g> in še <xliff:g id="COUNT_3">%d</xliff:g> datotek</item>
    </plurals>
    <string name="chooser_no_direct_share_targets" msgid="1511722103987329028">"Ni priporočenih oseb za deljenje vsebine"</string>
    <string name="chooser_all_apps_button_label" msgid="3230427756238666328">"Seznam aplikacij"</string>
    <string name="usb_device_resolve_prompt_warn" msgid="325871329788064199">"Ta aplikacija sicer nima dovoljenja za snemanje, vendar bi lahko zajemala zvok prek te naprave USB."</string>
    <string name="accessibility_system_action_home_label" msgid="3234748160850301870">"Začetni zaslon"</string>
    <string name="accessibility_system_action_back_label" msgid="4205361367345537608">"Nazaj"</string>
    <string name="accessibility_system_action_recents_label" msgid="4782875610281649728">"Nedavne aplikacije"</string>
    <string name="accessibility_system_action_notifications_label" msgid="6083767351772162010">"Obvestila"</string>
    <string name="accessibility_system_action_quick_settings_label" msgid="4583900123506773783">"Hitre nastavitve"</string>
    <string name="accessibility_system_action_power_dialog_label" msgid="8095341821683910781">"Pogovorno okno o porabi energije"</string>
    <string name="accessibility_system_action_lock_screen_label" msgid="5484190691945563838">"Zaklenjen zaslon"</string>
    <string name="accessibility_system_action_screenshot_label" msgid="3581566515062741676">"Posnetek zaslona"</string>
    <string name="accessibility_system_action_on_screen_a11y_shortcut_label" msgid="8488701469459210309">"Zaslonska bližnjica funkcij za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_system_action_on_screen_a11y_shortcut_chooser_label" msgid="1057878690209817886">"Izbirnik zaslonske bližnjice funkcij za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_system_action_hardware_a11y_shortcut_label" msgid="5764644187715255107">"Bližnjica funkcij za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_freeform_caption" msgid="8377519323496290122">"Vrstica s podnapisi aplikacije <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="as_app_forced_to_restricted_bucket" msgid="8233871289353898964">"Paket <xliff:g id="PACKAGE_NAME">%1$s</xliff:g> je bil dodan v segment OMEJENO"</string>
    <string name="conversation_single_line_name_display" msgid="8958948312915255999">"<xliff:g id="SENDER_NAME">%1$s</xliff:g>:"</string>
    <string name="conversation_single_line_image_placeholder" msgid="6983271082911936900">"je poslal(-a) sliko"</string>
    <string name="conversation_title_fallback_one_to_one" msgid="1980753619726908614">"Pogovor"</string>
    <string name="conversation_title_fallback_group_chat" msgid="456073374993104303">"Skupinski pogovor"</string>
    <string name="unread_convo_overflow" msgid="920517615597353833">"<xliff:g id="MAX_UNREAD_COUNT">%1$d</xliff:g>+"</string>
    <string name="resolver_personal_tab" msgid="2051260504014442073">"Osebno"</string>
    <string name="resolver_work_tab" msgid="2690019516263167035">"Služba"</string>
    <string name="resolver_personal_tab_accessibility" msgid="5739524949153091224">"Pogled osebnega profila"</string>
    <string name="resolver_work_tab_accessibility" msgid="4753168230363802734">"Pogled delovnega profila"</string>
    <string name="resolver_cant_share_with_work_apps" msgid="637686613606502219">"Tega ne smete deliti z delovnimi aplikacijami"</string>
    <string name="resolver_cant_share_with_work_apps_explanation" msgid="3332302070341130545">"Skrbnik za IT vam ne dovoli deljenja te vsebine z aplikacijami v delovnem profilu"</string>
    <string name="resolver_cant_access_work_apps" msgid="2455757966397563223">"Tega ne smete odpreti z delovnimi aplikacijami"</string>
    <string name="resolver_cant_access_work_apps_explanation" msgid="3626983885525445790">"Skrbnik za IT vam ne dovoli odpiranja te vsebine z aplikacijami v delovnem profilu"</string>
    <string name="resolver_cant_share_with_personal_apps" msgid="3079139799233316203">"Tega ne smete deliti z osebnimi aplikacijami"</string>
    <string name="resolver_cant_share_with_personal_apps_explanation" msgid="2959282422751315171">"Skrbnik za IT vam ne dovoli deljenja te vsebine z aplikacijami v osebnem profilu"</string>
    <string name="resolver_cant_access_personal_apps" msgid="648291604475669395">"Tega ne smete odpreti z osebnimi aplikacijami"</string>
    <string name="resolver_cant_access_personal_apps_explanation" msgid="2298773629302296519">"Skrbnik za IT vam ne dovoli odpiranja te vsebine z aplikacijami v osebnem profilu"</string>
    <string name="resolver_turn_on_work_apps" msgid="884910835250037247">"Delovni profil je začasno zaustavljen"</string>
    <string name="resolver_switch_on_work" msgid="2873009160846966379">"Vklop"</string>
    <string name="resolver_no_work_apps_available_share" msgid="7933949011797699505">"Nobena delovna aplikacija ne podpira te vsebine"</string>
    <string name="resolver_no_work_apps_available_resolve" msgid="1244844292366099399">"Nobena delovna aplikacija ne more odpreti te vsebine"</string>
    <string name="resolver_no_personal_apps_available_share" msgid="5639102815174748732">"Nobena osebna aplikacija ne podpira te vsebine"</string>
    <string name="resolver_no_personal_apps_available_resolve" msgid="5120671970531446978">"Nobena osebna aplikacija ne more odpreti te vsebine"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_ENTRY" msgid="8050953231914637819">"Koda PIN za odklepanje omrežja kartice SIM"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_ENTRY" msgid="7164399703751688214">"Koda PIN za odklepanje podnabora omrežja kartice SIM"</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_ENTRY" msgid="4447629474818217364">"Koda PIN za odklepanje kartice SIM za podjetje"</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_ENTRY" msgid="973059024670737358">"Koda PIN za odklepanje kartice SIM za ponudnika storitev"</string>
    <string name="PERSOSUBSTATE_SIM_SIM_ENTRY" msgid="4487435301206073787">"Koda PIN za odklepanje kartice SIM"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_PUK_ENTRY" msgid="768060297218652809">"Vnesite kodo PUK"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK_ENTRY" msgid="7129527319490548930">"Vnesite kodo PUK"</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_PUK_ENTRY" msgid="2876126640607573252">"Vnesite kodo PUK"</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK_ENTRY" msgid="8952595089930109282">"Vnesite kodo PUK"</string>
    <string name="PERSOSUBSTATE_SIM_SIM_PUK_ENTRY" msgid="3013902515773728996">"Vnesite kodo PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_ENTRY" msgid="2974411408893410289">"Koda PIN za odklepanje omrežja1 kartice RUIM"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_ENTRY" msgid="687618528751880721">"Koda PIN za odklepanje omrežja2 kartice RUIM"</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_ENTRY" msgid="6810596579655575381">"Koda PIN za odklepanje omrežja HRPD kartice RUIM"</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_ENTRY" msgid="2715929642540980259">"Koda PIN za odklepanje kartice RUIM za podjetje"</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_ENTRY" msgid="8557791623303951590">"Koda PIN za odklepanje kartice RUIM za ponudnika storitev"</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_ENTRY" msgid="7382468767274580323">"Koda PIN za odklepanje kartice RUIM"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_PUK_ENTRY" msgid="6730880791104286987">"Vnesite kodo PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_PUK_ENTRY" msgid="6432126539782267026">"Vnesite kodo PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_PUK_ENTRY" msgid="1730510161529488920">"Vnesite kodo PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK_ENTRY" msgid="3369885925003346830">"Vnesite kodo PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_PUK_ENTRY" msgid="9129139686191167829">"Vnesite kodo PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_PUK_ENTRY" msgid="2869929685874615358">"Vnesite kodo PUK"</string>
    <string name="PERSOSUBSTATE_SIM_SPN_ENTRY" msgid="1238663472392741771">"Koda PIN za odklepanje za SPN"</string>
    <string name="PERSOSUBSTATE_SIM_SP_EHPLMN_ENTRY" msgid="3988705848553894358">"Koda PIN za odklepanje enakovrednega domačega omrežja PLMN za ponudnika storitev"</string>
    <string name="PERSOSUBSTATE_SIM_ICCID_ENTRY" msgid="6186770686690993200">"Koda PIN za odklepanje ICCID"</string>
    <string name="PERSOSUBSTATE_SIM_IMPI_ENTRY" msgid="7043865376145617024">"Koda PIN za odklepanje IMPI"</string>
    <string name="PERSOSUBSTATE_SIM_NS_SP_ENTRY" msgid="6144227308185112176">"Koda PIN za odklepanje podnabora omrežja za ponudnika storitev"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_IN_PROGRESS" msgid="4233355366318061180">"Zahtevanje odklepanja omrežja kartice SIM …"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_IN_PROGRESS" msgid="6742563947637715645">"Zahtevanje odklepanja podnabora omrežja kartice SIM …"</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_IN_PROGRESS" msgid="2033399698172403560">"Zahtevanje odklepanja kartice SIM za ponudnika storitev …"</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_IN_PROGRESS" msgid="4795977251920732254">"Zahtevanje odklepanja kartice SIM za podjetje …"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_PUK_IN_PROGRESS" msgid="1090425878157254446">"Zahtevanje odklepanja s kodo PUK …"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK_IN_PROGRESS" msgid="6476898876518094438">"Zahtevanje odklepanja s kodo PUK …"</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_PUK_IN_PROGRESS" msgid="6006806734293747731">"Zahtevanje odklepanja s kodo PUK …"</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK_IN_PROGRESS" msgid="6546680489620881893">"Zahtevanje odklepanja s kodo PUK …"</string>
    <string name="PERSOSUBSTATE_SIM_SIM_PUK_IN_PROGRESS" msgid="3506845511000727015">"Zahtevanje odklepanja s kodo PUK …"</string>
    <string name="PERSOSUBSTATE_SIM_SIM_IN_PROGRESS" msgid="6709169861932992750">"Zahtevanje odklepanja kartice SIM …"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_IN_PROGRESS" msgid="4013870911606478520">"Zahtevanje odklepanja omrežja1 kartice RUIM …"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_IN_PROGRESS" msgid="9032651188219523434">"Zahtevanje odklepanja omrežja2 kartice RUIM …"</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_IN_PROGRESS" msgid="6584576506344491207">"Zahtevanje odklepanja omrežja HRPD kartice RUIM …"</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_IN_PROGRESS" msgid="830981927724888114">"Zahtevanje odklepanja kartice RUIM za ponudnika storitev …"</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_IN_PROGRESS" msgid="7851790973098894802">"Zahtevanje odklepanja kartice RUIM za podjetje …"</string>
    <string name="PERSOSUBSTATE_SIM_SPN_IN_PROGRESS" msgid="1149560739586960121">"Zahtevanje odklepanja za SPN …"</string>
    <string name="PERSOSUBSTATE_SIM_SP_EHPLMN_IN_PROGRESS" msgid="5708964693522116025">"Zahtevanje odklepanja enakovrednega domačega omrežja PLMN za ponudnika storitev …"</string>
    <string name="PERSOSUBSTATE_SIM_ICCID_IN_PROGRESS" msgid="7288103122966483455">"Zahtevanje odklepanja ICCID …"</string>
    <string name="PERSOSUBSTATE_SIM_IMPI_IN_PROGRESS" msgid="4036752174056147753">"Zahtevanje odklepanja IMPI …"</string>
    <string name="PERSOSUBSTATE_SIM_NS_SP_IN_PROGRESS" msgid="5089536274515338566">"Zahtevanje odklepanja podnabora omrežja za ponudnika storitev …"</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_IN_PROGRESS" msgid="6737197986936251958">"Zahtevanje odklepanja kartice RUIM …"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_PUK_IN_PROGRESS" msgid="5658767775619998623">"Zahtevanje odklepanja s kodo PUK …"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_PUK_IN_PROGRESS" msgid="665978313257653727">"Zahtevanje odklepanja s kodo PUK …"</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_PUK_IN_PROGRESS" msgid="3857142652251836850">"Zahtevanje odklepanja s kodo PUK …"</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_PUK_IN_PROGRESS" msgid="2695664012344346788">"Zahtevanje odklepanja s kodo PUK …"</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK_IN_PROGRESS" msgid="2695678959963807782">"Zahtevanje odklepanja s kodo PUK …"</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_PUK_IN_PROGRESS" msgid="1230605365926493599">"Zahtevanje odklepanja s kodo PUK …"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_ERROR" msgid="1924844017037151535">"Zahteva za odklepanje omrežja kartice SIM ni uspela."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_ERROR" msgid="3372797822292089708">"Zahteva za odklepanje podnabora omrežja kartice SIM ni uspela."</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_ERROR" msgid="1878443146720411381">"Zahteva za odklepanje kartice SIM za ponudnika storitev ni uspela."</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_ERROR" msgid="7664778312218023192">"Zahteva za odklepanje kartice SIM za podjetje ni uspela."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_ERROR" msgid="2472944311643350302">"Zahteva za odklepanje kartice SIM ni uspela."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_ERROR" msgid="828089694480999120">"Zahteva za odklepanje omrežja1 kartice RUIM ni uspela."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_ERROR" msgid="17619001007092511">"Zahteva za odklepanje omrežja2 kartice RUIM ni uspela."</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_ERROR" msgid="807214229604353614">"Zahteva za odklepanje omrežja HRPD kartice RUIM ni uspela."</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_ERROR" msgid="8644184447744175747">"Zahteva za odklepanje kartice RUIM za podjetje ni uspela."</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_ERROR" msgid="3801002648649640407">"Zahteva za odklepanje kartice RUIM za ponudnika storitev ni uspela."</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_ERROR" msgid="707397021218680753">"Zahteva za odklepanje kartice RUIM ni uspela."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_PUK_ERROR" msgid="894358680773257820">"Odklepanje s kodo PUK ni uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK_ERROR" msgid="352466878146726991">"Odklepanje s kodo PUK ni uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_PUK_ERROR" msgid="7353389721907138671">"Odklepanje s kodo PUK ni uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK_ERROR" msgid="2655263155490857920">"Odklepanje s kodo PUK ni uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_PUK_ERROR" msgid="6903740900892931310">"Odklepanje s kodo PUK ni uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_PUK_ERROR" msgid="5165901670447518687">"Odklepanje s kodo PUK ni uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_PUK_ERROR" msgid="2856763216589267623">"Odklepanje s kodo PUK ni uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_PUK_ERROR" msgid="817542684437829139">"Odklepanje s kodo PUK ni uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK_ERROR" msgid="5178635064113393143">"Odklepanje s kodo PUK ni uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_PUK_ERROR" msgid="5391587926974531008">"Odklepanje s kodo PUK ni uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_PUK_ERROR" msgid="4895494864493315868">"Odklepanje s kodo PUK ni uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_SPN_ERROR" msgid="9017576601595353649">"Zahteva za odklepanje za SPN ni uspela."</string>
    <string name="PERSOSUBSTATE_SIM_SP_EHPLMN_ERROR" msgid="1116993930995545742">"Zahteva za odklepanje enakovrednega domačega omrežja PLMN za ponudnika storitev ni uspela."</string>
    <string name="PERSOSUBSTATE_SIM_ICCID_ERROR" msgid="7559167306794441462">"Zahteva za odklepanje ICCID ni uspela."</string>
    <string name="PERSOSUBSTATE_SIM_IMPI_ERROR" msgid="2782926139511136588">"Zahteva za odklepanje IMPI ni uspela."</string>
    <string name="PERSOSUBSTATE_SIM_NS_SP_ERROR" msgid="1890493954453456758">"Zahteva za odklepanje podnabora omrežja za ponudnika storitev ni uspela."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUCCESS" msgid="4886243367747126325">"Odklepanje omrežja kartice SIM je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_SUCCESS" msgid="4053809277733513987">"Odklepanje podnabora omrežja kartice SIM je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_SUCCESS" msgid="8249342930499801740">"Odklepanje kartice SIM za ponudnika storitev je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_SUCCESS" msgid="2339794542560381270">"Odklepanje kartice SIM za podjetje je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_SUCCESS" msgid="6975608174152828954">"Odklepanje kartice SIM je uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_SUCCESS" msgid="2846699261330463192">"Odklepanje omrežja1 kartice RUIM je uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_SUCCESS" msgid="5335414726057102801">"Odklepanje omrežja2 kartice RUIM je uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_SUCCESS" msgid="8868100318474971969">"Odklepanje omrežja HRPD kartice RUIM je uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_SUCCESS" msgid="6020936629725666932">"Zahteva za odklepanje kartice RUIM za ponudnika storitev je uspela."</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_SUCCESS" msgid="6944873647584595489">"Odklepanje kartice RUIM za podjetje je uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_SUCCESS" msgid="2526483514124121988">"Odklepanje kartice RUIM je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_PUK_SUCCESS" msgid="7662200333621664621">"Odklepanje s kodo PUK je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK_SUCCESS" msgid="2861223407953766632">"Odklepanje s kodo PUK je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_PUK_SUCCESS" msgid="5345648571175243272">"Odklepanje s kodo PUK je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK_SUCCESS" msgid="3725278343103422466">"Odklepanje s kodo PUK je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_PUK_SUCCESS" msgid="6998502547560297983">"Odklepanje s kodo PUK je uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_PUK_SUCCESS" msgid="8555433771162560361">"Odklepanje s kodo PUK je uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_PUK_SUCCESS" msgid="3555767296933606232">"Odklepanje s kodo PUK je uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_PUK_SUCCESS" msgid="6778051818199974237">"Odklepanje s kodo PUK je uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_PUK_SUCCESS" msgid="4080108758498911429">"Odklepanje s kodo PUK je uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK_SUCCESS" msgid="7873675303000794343">"Odklepanje s kodo PUK je uspelo."</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_PUK_SUCCESS" msgid="1763198215069819523">"Odklepanje s kodo PUK je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_SPN_SUCCESS" msgid="2053891977727320532">"Odklepanje za SPN je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_SP_EHPLMN_SUCCESS" msgid="8146602361895007345">"Odklepanje enakovrednega domačega omrežja PLMN za ponudnika storitev je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_ICCID_SUCCESS" msgid="8058678548991999545">"Odklepanje ICCID je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_IMPI_SUCCESS" msgid="2545608067978550571">"Odklepanje IMPI je uspelo."</string>
    <string name="PERSOSUBSTATE_SIM_NS_SP_SUCCESS" msgid="4352382949744625007">"Odklepanje podnabora omrežja za ponudnika storitev je uspela."</string>
    <string name="config_pdp_reject_dialog_title" msgid="4072057179246785727"></string>
    <string name="config_pdp_reject_user_authentication_failed" msgid="4531693033885744689"></string>
    <string name="config_pdp_reject_service_not_subscribed" msgid="8190338397128671588"></string>
    <string name="config_pdp_reject_multi_conn_to_same_pdn_not_allowed" msgid="6024904218067254186"></string>
</resources>
