<?xml version="1.0" encoding="UTF-8"?>
<!-- 
/* //device/apps/common/assets/res/any/strings.xml
**
** Copyright 2006, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
**     http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
 -->

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="byteShort" msgid="8340973892742019101">"B"</string>
    <string name="kilobyteShort" msgid="5973789783504771878">"KB"</string>
    <string name="megabyteShort" msgid="6355851576770428922">"MB"</string>
    <string name="gigabyteShort" msgid="3259882455212193214">"GB"</string>
    <string name="terabyteShort" msgid="231613018159186962">"TB"</string>
    <string name="petabyteShort" msgid="5637816680144990219">"PB"</string>
    <string name="fileSizeSuffix" msgid="9164292791500531949">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="durationDays" msgid="6652371460511178259">"<xliff:g id="DAYS">%1$d</xliff:g> d"</string>
    <string name="durationDayHours" msgid="2713107458736744435">"<xliff:g id="DAYS">%1$d</xliff:g> d <xliff:g id="HOURS">%2$d</xliff:g> h"</string>
    <string name="durationDayHour" msgid="7293789639090958917">"<xliff:g id="DAYS">%1$d</xliff:g> d <xliff:g id="HOURS">%2$d</xliff:g> h"</string>
    <string name="durationHours" msgid="4266858287167358988">"<xliff:g id="HOURS">%1$d</xliff:g> h"</string>
    <string name="durationHourMinutes" msgid="9029176248692041549">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> min"</string>
    <string name="durationHourMinute" msgid="2741677355177402539">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> min"</string>
    <string name="durationMinutes" msgid="3134226679883579347">"<xliff:g id="MINUTES">%1$d</xliff:g> min"</string>
    <string name="durationMinuteSeconds" msgid="1424656185379003751">"<xliff:g id="MINUTES">%1$d</xliff:g> min <xliff:g id="SECONDS">%2$d</xliff:g> s"</string>
    <string name="durationMinuteSecond" msgid="3989228718067466680">"<xliff:g id="MINUTES">%1$d</xliff:g> min <xliff:g id="SECONDS">%2$d</xliff:g> s"</string>
    <string name="durationSeconds" msgid="8050088505238241405">"<xliff:g id="SECONDS">%1$d</xliff:g> s"</string>
    <string name="durationSecond" msgid="985669622276420331">"<xliff:g id="SECONDS">%1$d</xliff:g> s"</string>
    <string name="untitled" msgid="4638956954852782576">"&lt;Bez naslova&gt;"</string>
    <string name="ellipsis" msgid="7899829516048813237">"…"</string>
    <string name="ellipsis_two_dots" msgid="1228078994866030736">"‥"</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(Nema telefonskog broja)"</string>
    <string name="unknownName" msgid="2277556546742746522">"(Nepoznato)"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2660020990097733077">"Govorna pošta"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2850889754919584674">"MSISDN1"</string>
    <string name="mmiError" msgid="5154499457739052907">"Problem s vezom ili nevažeći MMI kôd."</string>
    <string name="mmiFdnError" msgid="5224398216385316471">"Operacija je ograničena samo na brojeve s fiksnim biranjem."</string>
    <string name="serviceEnabled" msgid="8147278346414714315">"Usluga nije omogućena."</string>
    <string name="serviceEnabledFor" msgid="6856228140453471041">"Usluga je omogućena za korisnika:"</string>
    <string name="serviceDisabled" msgid="1937553226592516411">"Usluga je onemogućena."</string>
    <string name="serviceRegistered" msgid="6275019082598102493">"Registracija je uspješna."</string>
    <string name="serviceErased" msgid="1288584695297200972">"Brisanje je bilo uspješno."</string>
    <string name="passwordIncorrect" msgid="7612208839450128715">"Pogrešna zaporka."</string>
    <string name="mmiComplete" msgid="8232527495411698359">"MMI dovršen."</string>
    <string name="badPin" msgid="9015277645546710014">"Stari PIN koji ste unijeli nije točan."</string>
    <string name="badPuk" msgid="5487257647081132201">"PUK koji ste unijeli nije točan."</string>
    <string name="mismatchPin" msgid="609379054496863419">"PIN-ovi koje ste unijeli međusobno se ne podudaraju."</string>
    <string name="invalidPin" msgid="3850018445187475377">"Unesite PIN koji ima od 4 do 8 brojeva."</string>
    <string name="invalidPuk" msgid="8761456210898036513">"Upišite PUK koji se sastoji od barem 8 brojeva."</string>
    <string name="needPuk" msgid="919668385956251611">"Vaša je SIM kartica zaključana PUK-om. Unesite PUK kôd da biste je otključali."</string>
    <string name="needPuk2" msgid="4526033371987193070">"Unesite PUK2 da biste odblokirali SIM karticu."</string>
    <string name="enablePin" msgid="209412020907207950">"Neuspješno; omogući zaključavanje SIM/RUIM."</string>
    <plurals name="pinpuk_attempts" formatted="false" msgid="1251012001539225582">
      <item quantity="one">Imate još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaj prije zaključavanja SIM kartice.</item>
      <item quantity="few">Imate još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaja prije zaključavanja SIM kartice.</item>
      <item quantity="other">Imate još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaja prije zaključavanja SIM kartice.</item>
    </plurals>
    <string name="imei" msgid="2625429890869005782">"IMEI"</string>
    <string name="meid" msgid="4841221237681254195">"MEID"</string>
    <string name="ClipMmi" msgid="6952821216480289285">"ID dolaznog pozivatelja"</string>
    <string name="ClirMmi" msgid="7784673673446833091">"ID izlaznog pozivatelja"</string>
    <string name="ColpMmi" msgid="3065121483740183974">"ID povezane linije"</string>
    <string name="ColrMmi" msgid="4996540314421889589">"Ograničenje ID-a povezane linije"</string>
    <string name="CfMmi" msgid="5123218989141573515">"Preusmjeravanje poziva"</string>
    <string name="CwMmi" msgid="9129678056795016867">"Poziv na čekanju"</string>
    <string name="BaMmi" msgid="455193067926770581">"Zabrana poziva"</string>
    <string name="PwdMmi" msgid="7043715687905254199">"Promjena zaporke"</string>
    <string name="PinMmi" msgid="3113117780361190304">"PIN je promijenjen"</string>
    <string name="CnipMmi" msgid="3110534680557857162">"Sadržan je pozivni broj"</string>
    <string name="CnirMmi" msgid="3062102121430548731">"Pozivni broj je ograničen"</string>
    <string name="ThreeWCMmi" msgid="9051047170321190368">"Trostrani poziv"</string>
    <string name="RuacMmi" msgid="7827887459138308886">"Odbijanje neželjenih i neugodnih poziva"</string>
    <string name="CndMmi" msgid="3116446237081575808">"Isporuka pozivnog broja"</string>
    <string name="DndMmi" msgid="1265478932418334331">"Ne uznemiravaj"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="429415409145781923">"Zadana postavka ID-a pozivatelja ima ograničenje. Sljedeći poziv: Ograničen"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="3092918006077864624">"Zadana postavka ID-a pozivatelja ima ograničenje. Sljedeći poziv: Nije ograničen"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="6179425182856418465">"Zadana postavka ID-a pozivatelja nema ograničenje. Sljedeći poziv: Ograničen"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2567998633124408552">"Zadana postavka ID-a pozivatelja nema ograničenje. Sljedeći poziv: Nije ograničen"</string>
    <string name="serviceNotProvisioned" msgid="8614830180508686666">"Usluga nije rezervirana."</string>
    <string name="CLIRPermanent" msgid="3377371145926835671">"Ne možete promijeniti postavku ID-a pozivatelja."</string>
    <string name="RestrictedChangedTitle" msgid="5592189398956187498">"Promijenjen je ograničeni pristup"</string>
    <string name="RestrictedOnData" msgid="8653794784690065540">"Podatkovna usluga je blokirana."</string>
    <string name="RestrictedOnEmergency" msgid="6581163779072833665">"Hitna usluga je blokirana."</string>
    <string name="RestrictedOnNormal" msgid="4953867011389750673">"Glasovna usluga je blokirana."</string>
    <string name="RestrictedOnAllVoice" msgid="3396963652108151260">"Sve su glasovne usluge blokirane."</string>
    <string name="RestrictedOnSms" msgid="8314352327461638897">"SMS usluga je blokirana."</string>
    <string name="RestrictedOnVoiceData" msgid="996636487106171320">"Glasovne/podatkovne usluge blokirane su."</string>
    <string name="RestrictedOnVoiceSms" msgid="1888588152792023873">"Glasovne/SMS usluge su blokirane."</string>
    <string name="RestrictedOnAll" msgid="5643028264466092821">"Sve su glasovne/podatkovne/SMS usluge blokirane."</string>
    <string name="serviceClassVoice" msgid="1258393812335258019">"Voice"</string>
    <string name="serviceClassData" msgid="872456782077937893">"Podaci"</string>
    <string name="serviceClassFAX" msgid="5566624998840486475">"Faks"</string>
    <string name="serviceClassSMS" msgid="2015460373701527489">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="4523454783498551468">"Asinkrono"</string>
    <string name="serviceClassDataSync" msgid="7530000519646054776">"Sinkronizacija"</string>
    <string name="serviceClassPacket" msgid="6991006557993423453">"Paket"</string>
    <string name="serviceClassPAD" msgid="3235259085648271037">"PAD"</string>
    <string name="roamingText0" msgid="7170335472198694945">"Pokazivač roaminga je uključen"</string>
    <string name="roamingText1" msgid="5314861519752538922">"Isključen pokazivač roaminga"</string>
    <string name="roamingText2" msgid="8969929049081268115">"Pokazivač roaminga bljeska"</string>
    <string name="roamingText3" msgid="5148255027043943317">"Izvan susjedstva"</string>
    <string name="roamingText4" msgid="8808456682550796530">"Izvan zgrade"</string>
    <string name="roamingText5" msgid="7604063252850354350">"Roaming - Željeni sustav"</string>
    <string name="roamingText6" msgid="2059440825782871513">"Roaming - Dostupan sustav"</string>
    <string name="roamingText7" msgid="7112078724097233605">"Roaming - Udruženi partner"</string>
    <string name="roamingText8" msgid="5989569778604089291">"Roaming - Premium Partner"</string>
    <string name="roamingText9" msgid="7969296811355152491">"Roaming - Potpun rad usluge"</string>
    <string name="roamingText10" msgid="3992906999815316417">"Roaming - Parcijalan rad usluge"</string>
    <string name="roamingText11" msgid="4154476854426920970">"Uključen je natpis roaminga"</string>
    <string name="roamingText12" msgid="1189071119992726320">"Isključen je natpis roaminga"</string>
    <string name="roamingTextSearching" msgid="8360141885972279963">"Pretraživanje usluge"</string>
    <string name="cfTemplateNotForwarded" msgid="1683685883841272560">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nije proslijeđeno"</string>
    <string name="cfTemplateForwarded" msgid="1302922117498590521">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g>"</string>
    <string name="cfTemplateForwardedTime" msgid="9206251736527085256">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g> nakon <xliff:g id="TIME_DELAY">{2}</xliff:g> s"</string>
    <string name="cfTemplateRegistered" msgid="5073237827620166285">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nije proslijeđeno"</string>
    <string name="cfTemplateRegisteredTime" msgid="6781621964320635172">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: nije proslijeđeno"</string>
    <string name="fcComplete" msgid="3118848230966886575">"Kôd značajke je potpun."</string>
    <string name="fcError" msgid="3327560126588500777">"Problem s vezom ili nevažeći kôd značajke."</string>
    <string name="httpErrorOk" msgid="1191919378083472204">"U redu"</string>
    <string name="httpError" msgid="7956392511146698522">"Došlo je pogreška mreže."</string>
    <string name="httpErrorLookup" msgid="4711687456111963163">"URL nije moguće pronaći."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="6299980280442076799">"Shema autentifikacije web-lokacije nije podržana."</string>
    <string name="httpErrorAuth" msgid="1435065629438044534">"Autentifikacija nije moguća."</string>
    <string name="httpErrorProxyAuth" msgid="1788207010559081331">"Provjera autentičnosti preko proxy poslužitelja nije bila uspješna."</string>
    <string name="httpErrorConnect" msgid="8714273236364640549">"Povezivanje s poslužiteljem nije moguće."</string>
    <string name="httpErrorIO" msgid="2340558197489302188">"Komunikacija s poslužiteljem nije moguća. Pokušajte ponovno kasnije."</string>
    <string name="httpErrorTimeout" msgid="4743403703762883954">"Veza s poslužiteljem privremeno je zaustavljena."</string>
    <string name="httpErrorRedirectLoop" msgid="8679596090392779516">"Stranica sadrži previše poslužiteljskih preusmjeravanja."</string>
    <string name="httpErrorUnsupportedScheme" msgid="5015730812906192208">"Protokol nije podržan."</string>
    <string name="httpErrorFailedSslHandshake" msgid="96549606000658641">"Sigurnu vezu nije moguće uspostaviti."</string>
    <string name="httpErrorBadUrl" msgid="3636929722728881972">"Stranicu nije moguće otvoriti zbog nevažećeg URL-a."</string>
    <string name="httpErrorFile" msgid="2170788515052558676">"Datoteku nije moguće otvoriti."</string>
    <string name="httpErrorFileNotFound" msgid="6203856612042655084">"Zatraženu datoteku nije moguće pronaći."</string>
    <string name="httpErrorTooManyRequests" msgid="1235396927087188253">"U obradi je previše zahtjeva. Pokušajte ponovo kasnije."</string>
    <string name="notification_title" msgid="8967710025036163822">"Pogreška prijave za račun <xliff:g id="ACCOUNT">%1$s</xliff:g>"</string>
    <string name="contentServiceSync" msgid="8353523060269335667">"Sinkronizacija"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="397743349191901458">"Sinkronizacija"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="8100981435080696431">"Previše brisanja stavki <xliff:g id="CONTENT_TYPE">%s</xliff:g>."</string>
    <string name="low_memory" product="tablet" msgid="6494019234102154896">"Prostor za pohranu tabletnog računala pun je. Izbrišite nekoliko datoteka kako biste oslobodili prostor."</string>
    <string name="low_memory" product="watch" msgid="4415914910770005166">"Memorija sata je puna. Izbrišite neke datoteke da biste oslobodili prostor."</string>
    <string name="low_memory" product="default" msgid="3475999286680000541">"Prostor za pohranu na telefonu je pun. Izbrišite nekoliko datoteka kako biste oslobodili prostor."</string>
    <string name="ssl_ca_cert_warning" msgid="5848402127455021714">"Mreža se možda nadzire"</string>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4475437862189850602">"Od strane nepoznate treće strane"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="4030263497686867141">"Od strane domene <xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="me" msgid="6545696007631404292">"Ja"</string>
    <string name="power_dialog" product="tablet" msgid="8545351420865202853">"Opcije tabletnog uređaja"</string>
    <string name="power_dialog" product="default" msgid="1319919075463988638">"Opcije telefona"</string>
    <string name="silent_mode" msgid="7167703389802618663">"Bešumni način"</string>
    <string name="turn_on_radio" msgid="3912793092339962371">"Uključi bežični prijenos"</string>
    <string name="turn_off_radio" msgid="8198784949987062346">"Isključi bežičnu vezu"</string>
    <string name="screen_lock" msgid="799094655496098153">"Zaključavanje zaslona"</string>
    <string name="power_off" msgid="4266614107412865048">"Isključi"</string>
    <string name="silent_mode_silent" msgid="319298163018473078">"Zvono isključeno"</string>
    <string name="silent_mode_vibrate" msgid="7072043388581551395">"Vibracija zvona"</string>
    <string name="silent_mode_ring" msgid="8592241816194074353">"Zvono uključeno"</string>
    <string name="shutdown_progress" msgid="2281079257329981203">"Isključivanje..."</string>
    <string name="shutdown_confirm" product="tablet" msgid="3385745179555731470">"Vaš tabletni uređaj će se isključiti."</string>
    <string name="shutdown_confirm" product="watch" msgid="3490275567476369184">"Sat će se isključiti."</string>
    <string name="shutdown_confirm" product="default" msgid="649792175242821353">"Vaš će se telefon isključiti."</string>
    <string name="shutdown_confirm_question" msgid="2906544768881136183">"Želite li isključiti uređaj?"</string>
    <string name="reboot_safemode_title" msgid="7054509914500140361">"Ponovno pokretanje u sigurnom načinu rada"</string>
    <string name="reboot_safemode_confirm" msgid="55293944502784668">"Želite li ponovo pokrenuti uređaj u sigurnom načinu rada? To će onemogućiti sve aplikacije treće strane koje ste instalirali. Bit će vraćene kada ponovo pokrenete uređaj."</string>
    <string name="recent_tasks_title" msgid="3691764623638127888">"Nedavni"</string>
    <string name="no_recent_tasks" msgid="8794906658732193473">"Nema nedavnih aplikacija."</string>
    <string name="global_actions" product="tablet" msgid="408477140088053665">"Opcije tabletnog uređaja"</string>
    <string name="global_actions" product="default" msgid="2406416831541615258">"Opcije telefona"</string>
    <string name="global_action_lock" msgid="2844945191792119712">"Zaključavanje zaslona"</string>
    <string name="global_action_power_off" msgid="4471879440839879722">"Isključi"</string>
    <string name="global_action_bug_report" msgid="7934010578922304799">"Izvješće o bugovima"</string>
    <string name="bugreport_title" msgid="2667494803742548533">"Izvješće o programskoj pogrešci"</string>
    <string name="bugreport_message" msgid="398447048750350456">"Time će se prikupiti podaci o trenutačnom stanju vašeg uređaja koje ćete nam poslati u e-poruci. Za pripremu izvješća o programskoj pogrešci potrebno je nešto vremena pa vas molimo za strpljenje."</string>
    <string name="global_action_toggle_silent_mode" msgid="8219525344246810925">"Bešumni način"</string>
    <string name="global_action_silent_mode_on_status" msgid="3289841937003758806">"Zvuk je isključen"</string>
    <string name="global_action_silent_mode_off_status" msgid="1506046579177066419">"Zvuk je uključen"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="5884330306926307456">"Način rada u zrakoplovu"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="2719557982608919750">"Uključen je način rada u zrakoplovu"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="5075070442854490296">"Isključen je način rada u zrakoplovu"</string>
    <string name="global_action_settings" msgid="1756531602592545966">"Postavke"</string>
    <string name="global_action_lockdown" msgid="8751542514724332873">"Zaključaj sada"</string>
    <string name="status_bar_notification_info_overflow" msgid="5301981741705354993">"999+"</string>
    <string name="safeMode" msgid="2788228061547930246">"Siguran način rada"</string>
    <string name="android_system_label" msgid="6577375335728551336">"Sustav Android"</string>
    <string name="user_owner_label" msgid="6465364741001216388">"Osobne aplikacije"</string>
    <string name="managed_profile_label" msgid="6260850669674791528">"Posao"</string>
    <string name="permgrouplab_costMoney" msgid="5429808217861460401">"Usluge koje se plaćaju"</string>
    <string name="permgroupdesc_costMoney" msgid="3293301903409869495">"Radite stvari koje će uzrokovati novčane troškove."</string>
    <string name="permgrouplab_messages" msgid="7521249148445456662">"Vaše poruke"</string>
    <string name="permgroupdesc_messages" msgid="7821999071003699236">"Čitajte i pišite SMS-ove, poruke e-pošte i ostale poruke."</string>
    <string name="permgrouplab_personalInfo" msgid="3519163141070533474">"Vaši osobni podaci"</string>
    <string name="permgroupdesc_personalInfo" msgid="8426453129788861338">"Izravan pristup informacijama o vama koje su pohranjene na vašoj posjetnici."</string>
    <string name="permgrouplab_socialInfo" msgid="5799096623412043791">"Aktivnost na društvenim mrežama"</string>
    <string name="permgroupdesc_socialInfo" msgid="7129842457611643493">"Izravan pristup informacijama o kontaktima i društvenim vezama."</string>
    <string name="permgrouplab_location" msgid="635149742436692049">"Vaša lokacija"</string>
    <string name="permgroupdesc_location" msgid="5704679763124170100">"Pratite svoju fizičku lokaciju."</string>
    <string name="permgrouplab_network" msgid="5808983377727109831">"Mrežna komunikacija"</string>
    <string name="permgroupdesc_network" msgid="4478299413241861987">"Pristupajte raznim značajkama mreže."</string>
    <string name="permgrouplab_bluetoothNetwork" msgid="1585403544162128109">"Bluetooth"</string>
    <string name="permgroupdesc_bluetoothNetwork" msgid="5625288577164282391">"Pristupajte uređajima i mrežama putem Bluetootha."</string>
    <string name="permgrouplab_audioSettings" msgid="8329261670151871235">"Postavke zvuka"</string>
    <string name="permgroupdesc_audioSettings" msgid="2641515403347568130">"Promjena postavki zvuka."</string>
    <string name="permgrouplab_affectsBattery" msgid="6209246653424798033">"Utječe na bateriju"</string>
    <string name="permgroupdesc_affectsBattery" msgid="6441275320638916947">"Upotreba značajki koje brzo prazne bateriju."</string>
    <string name="permgrouplab_calendar" msgid="5863508437783683902">"Kalendar"</string>
    <string name="permgroupdesc_calendar" msgid="5777534316982184416">"Izravan pristup kalendaru i događajima."</string>
    <string name="permgrouplab_dictionary" msgid="4148597128843641379">"Čitaj korisnički rječnik"</string>
    <string name="permgroupdesc_dictionary" msgid="7921166355964764490">"Pročitajte riječi u korisničkom rječniku."</string>
    <string name="permgrouplab_writeDictionary" msgid="8090237702432576788">"Piši u korisnički rječnik"</string>
    <string name="permgroupdesc_writeDictionary" msgid="2711561994497361646">"Dodavanje riječi u korisnički rječnik."</string>
    <string name="permgrouplab_bookmarks" msgid="1949519673103968229">"Oznake i povijest"</string>
    <string name="permgroupdesc_bookmarks" msgid="4169771606257963028">"Izravan pristup oznakama i povijest preglednika."</string>
    <string name="permgrouplab_deviceAlarms" msgid="6117704629728824101">"Alarm"</string>
    <string name="permgroupdesc_deviceAlarms" msgid="4769356362251641175">"Postavljanje alarma na budilici."</string>
    <string name="permgrouplab_voicemail" msgid="4162237145027592133">"Govorna pošta"</string>
    <string name="permgroupdesc_voicemail" msgid="2498403969862951393">"Izravan pristup govornoj pošti."</string>
    <string name="permgrouplab_microphone" msgid="171539900250043464">"Mikrofon"</string>
    <string name="permgroupdesc_microphone" msgid="7106618286905738408">"Izravan pristup mikrofonu za snimanje zvuka."</string>
    <string name="permgrouplab_camera" msgid="4820372495894586615">"Fotoaparat"</string>
    <string name="permgroupdesc_camera" msgid="2933667372289567714">"Izravan pristup fotoaparatu za slikanje ili snimanje videozapisa."</string>
    <string name="permgrouplab_screenlock" msgid="8275500173330718168">"Zaključan zaslon"</string>
    <string name="permgroupdesc_screenlock" msgid="7067497128925499401">"Mogućnost utjecanja na ponašanje zaključanog zaslona na uređaju."</string>
    <string name="permgrouplab_appInfo" msgid="8028789762634147725">"Informacije o vašoj aplikaciji"</string>
    <string name="permgroupdesc_appInfo" msgid="3950378538049625907">"Sposobnost da utječu na postupanje drugih aplikacija na vašem uređaju."</string>
    <string name="permgrouplab_wallpaper" msgid="3850280158041175998">"Pozadinska slika"</string>
    <string name="permgroupdesc_wallpaper" msgid="5630417854750540154">"Promjena postavki pozadinske slike na uređaju."</string>
    <string name="permgrouplab_systemClock" msgid="406535759236612992">"Sat"</string>
    <string name="permgroupdesc_systemClock" msgid="3944359833624094992">"Promjena vremena ili vremenske zone uređaja."</string>
    <string name="permgrouplab_statusBar" msgid="2095862568113945398">"Traka statusa"</string>
    <string name="permgroupdesc_statusBar" msgid="6242593432226807171">"Promijenite postavke statusne trake uređaja."</string>
    <string name="permgrouplab_syncSettings" msgid="3341990986147826541">"Postavke sinkronizacije"</string>
    <string name="permgroupdesc_syncSettings" msgid="7603195265129031797">"Pristup postavkama sinkronizacije."</string>
    <string name="permgrouplab_accounts" msgid="3359646291125325519">"Vaši računi"</string>
    <string name="permgroupdesc_accounts" msgid="4948732641827091312">"Pristup dostupnim računima."</string>
    <string name="permgrouplab_hardwareControls" msgid="7998214968791599326">"Hardverske kontrole"</string>
    <string name="permgroupdesc_hardwareControls" msgid="4357057861225462702">"Izravan pristup hardveru na mobilnom telefonu."</string>
    <string name="permgrouplab_phoneCalls" msgid="9067173988325865923">"Telefonski pozivi"</string>
    <string name="permgroupdesc_phoneCalls" msgid="7489701620446183770">"Praćenje, evidencija i obrada telefonskih poziva."</string>
    <string name="permgrouplab_systemTools" msgid="4652191644082714048">"Sistemski alati"</string>
    <string name="permgroupdesc_systemTools" msgid="8162102602190734305">"Niskorazinski pristup i nadzor nad sustavom."</string>
    <string name="permgrouplab_developmentTools" msgid="3446164584710596513">"Razvojni alati"</string>
    <string name="permgroupdesc_developmentTools" msgid="7058828032358142018">"Značajke potrebne samo za razvojne programere aplikacija."</string>
    <string name="permgrouplab_display" msgid="4279909676036402636">"Korisničko sučelje druge aplikacije"</string>
    <string name="permgroupdesc_display" msgid="6051002031933013714">"Utjecaj na korisničko sučelje drugih aplikacija."</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Prostor za pohranu"</string>
    <string name="permgroupdesc_storage" product="nosdcard" msgid="7442318502446874999">"Pristupi memoriji USB."</string>
    <string name="permgroupdesc_storage" product="default" msgid="9203302214915355774">"Pristup SD kartici."</string>
    <string name="permgrouplab_accessibilityFeatures" msgid="7919025602283593907">"Značajke dostupnosti"</string>
    <string name="permgroupdesc_accessibilityFeatures" msgid="4205196881678144335">"Značajke koje tehnologija za pristupačnost može zahtijevati."</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="3901717936930170320">"Dohvaćati sadržaj prozora"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="3772225008605310672">"Istražite sadržaj prozora koji upotrebljavate."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="3108723364676667320">"Uključiti značajku Istraži dodirom"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="5800552516779249356">"Dodirnute stavke izgovorit će se naglas, a zaslon se može istraživati pokretima."</string>
    <string name="capability_title_canRequestEnhancedWebAccessibility" msgid="1739881766522594073">"Uključiti poboljšanu pristupačnost weba"</string>
    <string name="capability_desc_canRequestEnhancedWebAccessibility" msgid="7881063961507511765">"Kako bi sadržaj aplikacije bio pristupačniji, mogu se instalirati skripte."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2103440391902412174">"Pratiti tekst koji pišete"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="7463135292204152818">"Uključuje osobne podatke kao što su brojevi kreditnih kartica i zaporke."</string>
    <string name="permlab_statusBar" msgid="7417192629601890791">"onemogućavanje ili izmjena trake statusa"</string>
    <string name="permdesc_statusBar" msgid="8434669549504290975">"Aplikaciji omogućuje onemogućavanje trake statusa ili dodavanje i uklanjanje sistemskih ikona."</string>
    <string name="permlab_statusBarService" msgid="7247281911387931485">"traka statusa"</string>
    <string name="permdesc_statusBarService" msgid="716113660795976060">"Aplikaciji omogućuje da bude traka statusa."</string>
    <string name="permlab_expandStatusBar" msgid="1148198785937489264">"proširivanje/sažimanje trake statusa"</string>
    <string name="permdesc_expandStatusBar" msgid="6917549437129401132">"Omogućuje aplikaciji proširivanje ili sažimanje trake statusa."</string>
    <string name="permlab_install_shortcut" msgid="4279070216371564234">"instaliranje prečaca"</string>
    <string name="permdesc_install_shortcut" msgid="8341295916286736996">"Aplikaciji omogućuje dodavanje prečaca početnog zaslona bez intervencije korisnika."</string>
    <string name="permlab_uninstall_shortcut" msgid="4729634524044003699">"deinstaliranje prečaca"</string>
    <string name="permdesc_uninstall_shortcut" msgid="6745743474265057975">"Aplikaciji omogućuje uklanjanje prečaca početnog zaslona bez intervencije korisnika."</string>
    <string name="permlab_processOutgoingCalls" msgid="3906007831192990946">"preusmjeravanje odlaznih poziva"</string>
    <string name="permdesc_processOutgoingCalls" msgid="5156385005547315876">"Omogućuje aplikaciji da vidi broj koji se bira prilikom odlaznog poziva uz opciju preusmjeravanja poziva na neki drugi broj ili prekidanja poziva."</string>
    <string name="permlab_receiveSms" msgid="8673471768947895082">"primanje tekstnih poruka (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="6424387754228766939">"Aplikaciji omogućuje primanje i obradu SMS poruka. To znači da aplikacija može nadzirati ili izbrisati poruke poslane na vaš uređaj, a da vam ih ne prikaže."</string>
    <string name="permlab_receiveMms" msgid="1821317344668257098">"primanje tekstnih poruka (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="533019437263212260">"Aplikaciji omogućuje primanje i obradu MMS poruka. To znači da aplikacija može nadzirati ili izbrisati poruke poslane na vaš uređaj, a da vam ih ne prikaže."</string>
    <string name="permlab_receiveEmergencyBroadcast" msgid="1803477660846288089">"primanje hitnih odašiljanja"</string>
    <string name="permdesc_receiveEmergencyBroadcast" msgid="848524070262431974">"Omogućuje aplikaciji primanje i obradu poruka hitnih odašiljanja. Ta je dozvola dostupna samo aplikacijama sustava."</string>
    <string name="permlab_readCellBroadcasts" msgid="1598328843619646166">"čitaj poruke koje se emitiraju unutar mobilne mreže"</string>
    <string name="permdesc_readCellBroadcasts" msgid="6361972776080458979">"Omogućuje aplikaciji čitanje poruka emitiranih unutar mobilne mreže koje prima vaš uređaj. Upozorenja koja se emitiraju na području mobilne mreže dostavljaju se na nekim lokacijama kako bi upozorila korisnike na hitne situacije. Zlonamjerne aplikacije mogu ometati izvršavanje ili rad vašeg uređaja kada stigne hitno upozorenje koje se emitira unutar mobilne mreže."</string>
    <string name="permlab_sendSms" msgid="5600830612147671529">"slanje SMS poruka"</string>
    <string name="permdesc_sendSms" msgid="7094729298204937667">"Aplikaciji omogućuje slanje SMS poruka. To može dovesti do neočekivanih troškova. Zlonamjerne aplikacije mogu vam uzrokovati dodatne troškove slanjem poruka bez vašeg odobrenja."</string>
    <string name="permlab_sendRespondViaMessageRequest" msgid="8713889105305943200">"slanje događaja \"odgovaranja porukom\""</string>
    <string name="permdesc_sendRespondViaMessageRequest" msgid="7107648548468778734">"Omogućuje aplikaciji slanje zahtijeva drugim aplikacijama za primanje i slanje poruka radi obrade događaja \"odgovaranja porukom\" za dolazne pozive."</string>
    <string name="permlab_readSms" msgid="8745086572213270480">"čitanje tekstnih poruka (SMS ili MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="2467981548684735522">"Aplikaciji omogućuje čitanje SMS poruka pohranjenih na tabletnom računalu ili SIM kartici. To aplikaciji omogućuje čitanje svih SMS poruka, neovisno o sadržaju ili povjerljivosti."</string>
    <string name="permdesc_readSms" product="default" msgid="3695967533457240550">"Aplikaciji omogućuje čitanje SMS poruka pohranjenih na telefonu ili SIM kartici. To aplikaciji omogućuje čitanje svih SMS poruka, neovisno o sadržaju ili povjerljivosti."</string>
    <string name="permlab_writeSms" msgid="3216950472636214774">"uređivanje tekstnih poruka (SMS ili MMS)"</string>
    <string name="permdesc_writeSms" product="tablet" msgid="5160413947794501538">"Omogućuje aplikaciji pisanje u SMS poruke pohranjene na vašem tabletnom računalu ili SIM kartici. Zlonamjerne aplikacije mogu izbrisati vaše poruke."</string>
    <string name="permdesc_writeSms" product="default" msgid="7268668709052328567">"Omogućuje aplikaciji pisanje u SMS poruke pohranjene na telefonu ili SIM kartici. Zlonamjerne aplikacije mogu izbrisati vaše poruke."</string>
    <string name="permlab_receiveWapPush" msgid="5991398711936590410">"primanje tekstnih poruka (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="748232190220583385">"Aplikaciji omogućuje primanje i obradu WAP poruka. Ta dozvola uključuje mogućnost nadziranja ili brisanja vama poslanih poruka, a da vam ih ne prikaže."</string>
    <string name="permlab_receiveBluetoothMap" msgid="7593811487142360528">"primaj Bluetooth poruke (MAP)"</string>
    <string name="permdesc_receiveBluetoothMap" msgid="8656755936919466345">"Aplikaciji omogućuje primanje i obradu Bluetooth MAP poruka. To znači da aplikacija može nadzirati ili brisati poruke poslane na vaš uređaj, a da vam ih ne prikaže."</string>
    <string name="permlab_getTasks" msgid="6466095396623933906">"dohvaćanje pokrenutih aplikacija"</string>
    <string name="permdesc_getTasks" msgid="7454215995847658102">"Aplikaciji omogućuje dohvaćanje informacija o trenutačnim i nedavnim tekućim zadacima. To aplikaciji može omogućiti otkrivanje informacija o tome koje se aplikacije upotrebljavaju na uređaju."</string>
    <string name="permlab_startTasksFromRecents" msgid="8990073877885690623">"pokretanje zadatka iz najnovijih"</string>
    <string name="permdesc_startTasksFromRecents" msgid="7382133554871222235">"Omogućuje aplikaciji upotrebu ActivityManager.RecentTaskInfo objekta za pokretanje zadatka koji više nije u funkciji vraćenog s ActivityManager.getRecentTaskList()."</string>
    <string name="permlab_interactAcrossUsers" msgid="7114255281944211682">"interakcija među korisnicima"</string>
    <string name="permdesc_interactAcrossUsers" msgid="364670963623385786">"Omogućuje aplikaciji izvršavanje radnji među korisnicima na uređaju. Zlonamjerne aplikacije mogu to iskoristiti za narušavanje zaštite među korisnicima."</string>
    <string name="permlab_interactAcrossUsersFull" msgid="2567734285545074105">"dozvola za potpunu interakciju među korisnicima"</string>
    <string name="permdesc_interactAcrossUsersFull" msgid="376841368395502366">"Omogućuje sve moguće interakcije među korisnicima."</string>
    <string name="permlab_manageUsers" msgid="1676150911672282428">"upravljanje korisnicima"</string>
    <string name="permdesc_manageUsers" msgid="8409306667645355638">"Omogućuje aplikacijama upravljanje korisnicima na uređaju, uključujući upit, izradu i brisanje."</string>
    <string name="permlab_getDetailedTasks" msgid="6229468674753529501">"dohvaćanje pojedinosti o pokrenutim aplikacijama"</string>
    <string name="permdesc_getDetailedTasks" msgid="153824741440717599">"Aplikaciji omogućuje dohvaćanje detaljnih informacija o trenutačno i nedavno pokrenutim zadacima. Zlonamjerne aplikacije mogu otkriti privatne informacije o drugim aplikacijama."</string>
    <string name="permlab_reorderTasks" msgid="2018575526934422779">"promjena redoslijeda pokrenutih aplikacija"</string>
    <string name="permdesc_reorderTasks" msgid="7734217754877439351">"Aplikaciji omogućuje premještanje zadataka u prednji plan ili pozadinu. Aplikacija to može napraviti bez vašeg naloga."</string>
    <string name="permlab_removeTasks" msgid="6821513401870377403">"zaustavljanje pokrenutih aplikacija"</string>
    <string name="permdesc_removeTasks" msgid="1394714352062635493">"Omogućuje aplikaciji uklanjanje zadataka i uklanjanje njihovih aplikacija. Zlonamjerne aplikacije mogu poremetiti rad drugih aplikacija."</string>
    <string name="permlab_manageActivityStacks" msgid="7391191384027303065">"upravljaj snopovima aktivnosti"</string>
    <string name="permdesc_manageActivityStacks" msgid="1615881933034084440">"Dopušta aplikaciji dodavanje, uklanjanje i izmjenu snopova aktivnosti u kojima se druge aplikacije izvršavaju. Zlonamjerne aplikacije mogu poremetiti ponašanje ostalih aplikacija."</string>
    <string name="permlab_startAnyActivity" msgid="2918768238045206456">"započni bilo kakvu aktivnost"</string>
    <string name="permdesc_startAnyActivity" msgid="997823695343584001">"Omogućuje aplikaciji da započne bilo koju aktivnost, bez obzira na zaštitu pomoću dozvola ili stanje izvoza."</string>
    <string name="permlab_setScreenCompatibility" msgid="6975387118861842061">"postavljanje kompatibilnosti sa zaslonom"</string>
    <string name="permdesc_setScreenCompatibility" msgid="692043618693917374">"Aplikaciji omogućuje upravljanje načinom kompatibilnosti aplikacija sa zaslonom. Zlonamjerne aplikacije mogu prekinuti takvo ponašanje ostalih aplikacija."</string>
    <string name="permlab_setDebugApp" msgid="3022107198686584052">"omogućavanje rješavanja programskih pogrešaka u aplikaciji"</string>
    <string name="permdesc_setDebugApp" msgid="4474512416299013256">"Omogućuje aplikaciji uključivanje uklanjanja programskih pogrešaka za drugu aplikaciju. Zlonamjerne aplikacije mogu na taj način ukloniti druge aplikacije."</string>
    <string name="permlab_changeConfiguration" msgid="4162092185124234480">"promjena postavki prikaza sustava"</string>
    <string name="permdesc_changeConfiguration" msgid="4372223873154296076">"Aplikaciji omogućuje promjenu trenutačne konfiguracije kao što je oznaka zemlje/jezika ili opća veličina fonta."</string>
    <string name="permlab_enableCarMode" msgid="5684504058192921098">"omogućavanje načina rada za automobil"</string>
    <string name="permdesc_enableCarMode" msgid="4853187425751419467">"Aplikaciji omogućuje uključivanje načina rada u vožnji."</string>
    <string name="permlab_killBackgroundProcesses" msgid="3914026687420177202">"zatvaranje ostalih aplikacija"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="4593353235959733119">"Aplikaciji omogućuje završavanje pozadinskih procesa drugih aplikacija. To može dovesti do prekida rada drugih aplikacija."</string>
    <string name="permlab_forceStopPackages" msgid="2329627428832067700">"prisilno zaustavljanje ostalih aplikacija"</string>
    <string name="permdesc_forceStopPackages" msgid="5253157296183940812">"Aplikaciji omogućuje prisilno zaustavljanje drugih aplikacija."</string>
    <string name="permlab_forceBack" msgid="652935204072584616">"prisilno zatvaranje aplikacije"</string>
    <string name="permdesc_forceBack" msgid="3892295830419513623">"Omogućuje aplikaciji prisilno zatvaranje i povratak svih radnji u prednjem planu. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_dump" msgid="1681799862438954752">"dohvaćanje internog stanja sustava"</string>
    <string name="permdesc_dump" msgid="1778299088692290329">"Omogućuje aplikaciji dohvaćanje unutarnjeg stanja sustava. Zlonamjerne aplikacije mogu dohvatiti razne privatne i sigurnosne podatke koje im inače nikada ne bi trebale biti potrebne."</string>
    <string name="permlab_retrieve_window_content" msgid="8022588608994589938">"dohvaćanje sadržaja zaslona"</string>
    <string name="permdesc_retrieve_window_content" msgid="3193269069469700265">"Omogućuje aplikaciji dohvaćanje sadržaja aktivnog prozora. Zlonamjerne aplikacije mogu dohvatiti sav sadržaj prozora i pregledati sav njegov tekst osim zaporki."</string>
    <string name="permlab_temporary_enable_accessibility" msgid="2312612135127310254">"privremeno omogući dostupnost"</string>
    <string name="permdesc_temporary_enable_accessibility" msgid="8079456293182975464">"Aplikacija može privremeno omogućiti dostupnost na uređaju. Zlonamjerne aplikacije mogu omogućiti dostupnost bez korisnikova odobrenja."</string>
    <string name="permlab_retrieveWindowToken" msgid="7154762602367758602">"učitavanje prozora tokena"</string>
    <string name="permdesc_retrieveWindowToken" msgid="668173747687795074">"Omogućuje aplikaciji učitavanje tokena prozora. Zlonamjerne aplikacije mogu stupati u neovlaštenu interakciju s prozorom aplikacije lažno se predstavljajući kao sustav."</string>
    <string name="permlab_frameStats" msgid="7056374987314361639">"učitavanje statističkih pokazatelja okvira"</string>
    <string name="permdesc_frameStats" msgid="4758001089491284919">"Omogućuje aplikaciji prikupljanje statističkih podataka okvira. Zlonamjerne aplikacije mogu pratiti statističke podatke okvira prozora iz drugih aplikacija."</string>
    <string name="permlab_filter_events" msgid="8675535648807427389">"filtriranje događaja"</string>
    <string name="permdesc_filter_events" msgid="8006236315888347680">"Aplikaciji omogućuje registraciju ulaznog filtra koji filtrira strujanje svih korisničkih događaja prije otpreme. Zlonamjerne aplikacije mogu kontrolirati korisničko sučelje sustava bez znanja korisnika."</string>
    <string name="permlab_shutdown" msgid="7185747824038909016">"djelomično isključivanje"</string>
    <string name="permdesc_shutdown" msgid="7046500838746291775">"Postavlja upravitelja za aktivnost u stanje mirovanja. Ne isključuje ga u potpunosti."</string>
    <string name="permlab_stopAppSwitches" msgid="4138608610717425573">"sprečavanje promjene aplikacije"</string>
    <string name="permdesc_stopAppSwitches" msgid="8262195802582255021">"Sprječava korisnika u prebacivanju na drugu aplikaciju."</string>
    <string name="permlab_getTopActivityInfo" msgid="2537922311411546016">"dohvaćanje informacija o trenutačnoj aplikaciji"</string>
    <string name="permdesc_getTopActivityInfo" msgid="2512448855496067131">"Omogućuje nositelju dohvaćanje privatnih informacija o trenutačnoj aplikaciji u prednjem planu na zaslonu."</string>
    <string name="permlab_runSetActivityWatcher" msgid="892239094867182656">"praćenje i nadzor svih pokretanja aplikacija"</string>
    <string name="permdesc_runSetActivityWatcher" msgid="6003603162578577406">"Omogućuje aplikaciji nadzor i upravljanje načinom na koji sustav pokreće aktivnosti. Zlonamjerne aplikacije mogu posve ugroziti sustav. Ta je dozvola potrebna samo za razvoj, nikada za uobičajenu upotrebu."</string>
    <string name="permlab_broadcastPackageRemoved" msgid="2576333434893532475">"slanje paketno uklonjenog prijenosa"</string>
    <string name="permdesc_broadcastPackageRemoved" msgid="6621901216207931089">"Omogućuje aplikaciji emitiranje obavijesti da je paket aplikacija uklonjen. Zlonamjerne aplikacije mogu to upotrijebiti za uklanjanje svih ostalih pokrenutih aplikacija."</string>
    <string name="permlab_broadcastSmsReceived" msgid="5689095009030336593">"slanje prijenosa primljenih SMS-om"</string>
    <string name="permdesc_broadcastSmsReceived" msgid="4152037720034365492">"Omogućuje aplikaciji emitiranje obavijesti da je primljena SMS poruka. Zlonamjerne aplikacije mogu to upotrijebiti za krivotvorenje dolaznih SMS poruka."</string>
    <string name="permlab_broadcastWapPush" msgid="3145347413028582371">"slanje WAP-PUSH-primljenih prijenosa"</string>
    <string name="permdesc_broadcastWapPush" msgid="4783402525039442729">"Omogućuje aplikaciji emitiranje obavijesti da je primljena WAP PUSH poruka. Zlonamjerne aplikacije mogu to upotrijebiti da bi krivotvorile prijem MMS poruka ili da bi potajno zamijenile sadržaj bilo koje web-stranice zlonamjernim varijantama."</string>
    <string name="permlab_setProcessLimit" msgid="2451873664363662666">"ograničavanje broja pokrenutih postupaka"</string>
    <string name="permdesc_setProcessLimit" msgid="7318061314040879542">"Omogućuje aplikaciji upravljanje maksimalnim brojem postupaka koji će biti pokrenuti. Nikada nije potrebno za uobičajene aplikacije."</string>
    <string name="permlab_setAlwaysFinish" msgid="550958507798796965">"prisilno zatvaranje pozadinskih aplikacija"</string>
    <string name="permdesc_setAlwaysFinish" msgid="7471310652868841499">"Omogućuje aplikaciji da upravlja time hoće li radnje uvijek prekinuti s radom čim odu u pozadinu. Nikada nije potrebno za normalne aplikacije."</string>
    <string name="permlab_batteryStats" msgid="2789610673514103364">"očitavanje statistike o bateriji"</string>
    <string name="permdesc_batteryStats" msgid="5897346582882915114">"Aplikacija može očitavati podatke o trenutačnoj potrošnji baterije na niskoj razini. Tako može doznati detaljne informacije o aplikacijama koje upotrebljavate."</string>
    <string name="permlab_updateBatteryStats" msgid="3719689764536379557">"izmjena statistike o bateriji"</string>
    <string name="permdesc_updateBatteryStats" msgid="6862817857178025002">"Omogućuje aplikaciji promjenu prikupljene statistike o potrošnji baterije. Nije namijenjena uobičajenim aplikacijama."</string>
    <string name="permlab_getAppOpsStats" msgid="1508779687436585744">"dohvaćanje statistike o radu aplikacije"</string>
    <string name="permdesc_getAppOpsStats" msgid="6243887041577912877">"Aplikaciji omogućuje dohvaćanje prikupljene statistike o radu aplikacije. Nije namijenjena uobičajenim aplikacijama."</string>
    <string name="permlab_updateAppOpsStats" msgid="8829097373851521505">"izmjena statistike o radu aplikacije"</string>
    <string name="permdesc_updateAppOpsStats" msgid="50784596594403483">"Aplikaciji omogućuje promjenu prikupljene statistike o radu aplikacije. Nije namijenjena uobičajenim aplikacijama."</string>
    <string name="permlab_backup" msgid="470013022865453920">"sigurnosna kopija i oporavak nadzornog sustava"</string>
    <string name="permdesc_backup" msgid="6912230525140589891">"Omogućuje aplikaciji upravljanje mehanizmom stvaranja sigurnosnih kopija i obnove sustava. Nije namijenjena uobičajenim aplikacijama."</string>
    <string name="permlab_confirm_full_backup" msgid="5557071325804469102">"potvrditi postupak izrade sigurnosne kopije ili obnove"</string>
    <string name="permdesc_confirm_full_backup" msgid="1748762171637699562">"Omogućuje aplikaciji pokretanje korisničkog sučelja za potvrdu potpune sigurnosne kopije. Aplikacije ne bi trebale upotrebljavati tu opciju."</string>
    <string name="permlab_internalSystemWindow" msgid="2148563628140193231">"prikaz neovlaštenih prozora"</string>
    <string name="permdesc_internalSystemWindow" msgid="7458387759461466397">"Omogućuje aplikaciji stvaranje prozora koje bi trebalo upotrebljavati korisničko sučelje internog sustava. Nije namijenjeno uobičajenim aplikacijama."</string>
    <string name="permlab_systemAlertWindow" msgid="3543347980839518613">"crtanje preko drugih aplikacija"</string>
    <string name="permdesc_systemAlertWindow" msgid="8584678381972820118">"Aplikacija može crtati preko drugih aplikacija ili dijelova korisničkog sučelja. Može ometati upotrebu sučelja na bilo kojoj aplikaciji ili promijeniti izgled drugih aplikacija."</string>
    <string name="permlab_setAnimationScale" msgid="2805103241153907174">"izmjena globalne brzine animacije"</string>
    <string name="permdesc_setAnimationScale" msgid="7690063428924343571">"U bilo kojem trenutku aplikaciji omogućuje promjenu globalne brzine animacija (brža ili sporija animacija)."</string>
    <string name="permlab_manageAppTokens" msgid="1286505717050121370">"upravljanje oznakama aplikacije"</string>
    <string name="permdesc_manageAppTokens" msgid="8043431713014395671">"Omogućuje aplikaciji stvaranje vlastitih oznaka i upravljanje njima, zaobilazeći njihov uobičajeni Z-redoslijed. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_freezeScreen" msgid="4708181184441880175">"zamrzni ekran"</string>
    <string name="permdesc_freezeScreen" msgid="8558923789222670064">"Omogućuje aplikaciji privremeno zamrzavanje zaslona za prijelaz na cijeli zaslon."</string>
    <string name="permlab_injectEvents" msgid="1378746584023586600">"pritisnite tipke i gumbe za nadzor"</string>
    <string name="permdesc_injectEvents" product="tablet" msgid="206352565599968632">"Omogućuje aplikaciji slanje vlastitih ulaznih događaja (pritiskanje tipki itd.) drugim aplikacijama. Zlonamjerne aplikacije na taj način mogu preuzeti tabletno računalo."</string>
    <string name="permdesc_injectEvents" product="default" msgid="653128057572326253">"Omogućuje aplikaciji slanje vlastitih ulaznih događaja (pritiskanje tipki itd.) drugim aplikacijama. Zlonamjerne aplikacije na taj način mogu preuzeti telefon."</string>
    <string name="permlab_readInputState" msgid="469428900041249234">"bilježi što pišete i koje radnje poduzimate"</string>
    <string name="permdesc_readInputState" msgid="8387754901688728043">"Omogućuje aplikaciji da gleda koje tipke pritiskate čak i kada radite s nekom drugom aplikacijom (na primjer, pisanje zaporke). Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_bindInputMethod" msgid="3360064620230515776">"vezano uz način unosa"</string>
    <string name="permdesc_bindInputMethod" msgid="3250440322807286331">"Nositelju omogućuje povezivanje sučelja najviše razine načina unosa. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_bindAccessibilityService" msgid="5357733942556031593">"vezivanje uz uslugu dostupnosti"</string>
    <string name="permdesc_bindAccessibilityService" msgid="7034615928609331368">"Nositelju omogućuje vezanje uz sučelje najviše razine usluge dostupnosti. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_bindPrintService" msgid="8462815179572748761">"veži se uz uslugu ispisa"</string>
    <string name="permdesc_bindPrintService" msgid="7960067623209111135">"Dopušta nositelju vezanje uza sučelje usluge ispisa najviše razine. Ne bi smjelo biti potrebno za uobičajene aplikacije."</string>
    <string name="permlab_bindPrintSpoolerService" msgid="6807762783744125954">"veži se uz uslugu predmemoriranja ispisa"</string>
    <string name="permdesc_bindPrintSpoolerService" msgid="3680552285933318372">"Dopušta nositelju vezanje uza sučelje usluge predmemoriranja ispisa najviše razine. Ne bi smjelo biti potrebno za uobičajene aplikacije."</string>
    <string name="permlab_bindNfcService" msgid="2752731300419410724">"povezivanje s NFC uslugom"</string>
    <string name="permdesc_bindNfcService" msgid="6120647629174066862">"Omogućuje nositelju povezivanje s aplikacijama koje emuliraju NFC kartice. Nikada ne bi trebalo biti potrebno za uobičajene aplikacije."</string>
    <string name="permlab_bindTextService" msgid="7358378401915287938">"vezanje na tekstualnu uslugu"</string>
    <string name="permdesc_bindTextService" msgid="8151968910973998670">"Omogućuje korisniku povezivanje s najvišom razinom sučelja tekstualne usluge (npr. SpellCheckerService). Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_bindVpnService" msgid="4708596021161473255">"vezanje na VPN uslugu"</string>
    <string name="permdesc_bindVpnService" msgid="2067845564581693905">"Nositelju omogućuje vezanje uz sučelje najviše razine VPN usluge. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_bindWallpaper" msgid="8716400279937856462">"povezano s pozadinskom slikom"</string>
    <string name="permdesc_bindWallpaper" msgid="7108428692595491668">"Nositelju omogućuje povezivanje sa sučeljem pozadinske slike najviše razine. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_bindVoiceInteraction" msgid="5334852580713715068">"povezivanje s uslugom glasovne interakcije"</string>
    <string name="permdesc_bindVoiceInteraction" msgid="2345721766501778101">"Vlasniku omogućuje povezivanje sa sučeljem najviše razine usluge glasovne interakcije. Nije potrebno za normalne aplikacije."</string>
    <string name="permlab_manageVoiceKeyphrases" msgid="1252285102392793548">"upravljanje glasovnim ključnim frazama"</string>
    <string name="permdesc_manageVoiceKeyphrases" msgid="8476560722907530008">"Omogućuje korisniku upravljanje ključnim frazama za otkrivanje glasovnih pokretača značajke. Ne bi trebalo biti potrebno za uobičajene aplikacije."</string>
    <string name="permlab_bindRemoteDisplay" msgid="1782923938029941960">"vezanje uz udaljeni zaslon"</string>
    <string name="permdesc_bindRemoteDisplay" msgid="1261242718727295981">"Nositelju omogućuje vezanje uza sučelje najviše razine udaljenog zaslona. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_bindRemoteViews" msgid="5697987759897367099">"vezanje na uslugu widgeta"</string>
    <string name="permdesc_bindRemoteViews" msgid="4717987810137692572">"Nositelju omogućuje vezanje uz sučelje najviše razine usluge widgeta. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_bindDeviceAdmin" msgid="8704986163711455010">"interakcija s administratorom uređaja"</string>
    <string name="permdesc_bindDeviceAdmin" msgid="569715419543907930">"Nositelju omogućuje slanje namjera administratoru uređaja. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_bindTvInput" msgid="5601264742478168987">"povezivanje s TV ulazom"</string>
    <string name="permdesc_bindTvInput" msgid="2371008331852001924">"Nositelju omogućuje vezanje uz sučelje najviše razine TV ulaza. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_modifyParentalControls" msgid="4611318225997592242">"izmjena roditeljskog nadzora"</string>
    <string name="permdesc_modifyParentalControls" msgid="7438482894162282039">"Omogućuje vlasniku izmjenu podataka o roditeljskom nadzoru sustava. Ne bi trebalo biti potrebno za uobičajene aplikacije."</string>
    <string name="permlab_manageDeviceAdmins" msgid="4248828900045808722">"dodavanje ili uklanjanje administratora uređaja"</string>
    <string name="permdesc_manageDeviceAdmins" msgid="5025608167709942485">"Omogućuje nositelju dodavanje ili uklanjanje administratora aktivnih uređaja. Nikada ne bi trebalo biti potrebno za uobičajene aplikacije."</string>
    <string name="permlab_setOrientation" msgid="3365947717163866844">"promjena orijentacije zaslona"</string>
    <string name="permdesc_setOrientation" msgid="3046126619316671476">"Omogućuje aplikaciji promjenu rotacije zaslona u bilo kojem trenutku. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_setPointerSpeed" msgid="9175371613322562934">"promjena brzine pokazivača"</string>
    <string name="permdesc_setPointerSpeed" msgid="6866563234274104233">"Omogućuje aplikaciji promjenu brzine miša ili dodirne pločice. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_setKeyboardLayout" msgid="4778731703600909340">"promjena rasporeda tipkovnice"</string>
    <string name="permdesc_setKeyboardLayout" msgid="8480016771134175879">"Omogućuje da aplikacija promijeni raspored tipkovnice. Nikada ne bi trebalo biti potrebno za uobičajene aplikacije."</string>
    <string name="permlab_signalPersistentProcesses" msgid="4539002991947376659">"slanje Linux signala aplikacijama"</string>
    <string name="permdesc_signalPersistentProcesses" msgid="4896992079182649141">"Aplikaciji omogućuje zahtijevanje da isporučeni signal bude poslan na sve trajne procese."</string>
    <string name="permlab_persistentActivity" msgid="8841113627955563938">"trajni rad aplikacije"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="8525189272329086137">"Aplikaciji omogućuje trajnu prisutnost nekih njenih dijelova u memoriji. To može ograničiti dostupnost memorije drugim aplikacijama i usporiti tabletno računalo."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="4384760047508278272">"Aplikaciji omogućuje trajnu prisutnost nekih njenih dijelova u memoriji. To može ograničiti dostupnost memorije drugim aplikacijama i usporiti telefon."</string>
    <string name="permlab_deletePackages" msgid="184385129537705938">"izbrisati aplikacije"</string>
    <string name="permdesc_deletePackages" msgid="7411480275167205081">"Omogućuje aplikaciji brisanje Androidovih paketa. Zlonamjerne aplikacije mogu to upotrijebiti za brisanje važnih aplikacija."</string>
    <string name="permlab_clearAppUserData" msgid="274109191845842756">"brisanje ostalih podataka aplikacije"</string>
    <string name="permdesc_clearAppUserData" msgid="4625323684125459488">"Aplikaciji omogućuje brisanje korisničkih podataka."</string>
    <string name="permlab_deleteCacheFiles" msgid="3128665571837408675">"brisanje predmemorije ostalih aplikacija"</string>
    <string name="permdesc_deleteCacheFiles" msgid="3812998599006730196">"Aplikaciji omogućuje brisanje datoteka predmemorije."</string>
    <string name="permlab_getPackageSize" msgid="7472921768357981986">"mjerenje prostora za pohranu aplikacije"</string>
    <string name="permdesc_getPackageSize" msgid="3921068154420738296">"Aplikaciji omogućuje dohvaćanje koda, podataka i veličine predmemorije"</string>
    <string name="permlab_installPackages" msgid="2199128482820306924">"izravno instaliranje aplikacija"</string>
    <string name="permdesc_installPackages" msgid="5628530972548071284">"Omogućuje aplikaciji instaliranje novih ili ažuriranih Androidovih paketa. Zlonamjerne aplikacije mogu na taj način dodati nove aplikacije s proizvoljno moćnim dozvolama."</string>
    <string name="permlab_clearAppCache" msgid="7487279391723526815">"brisanje svih podataka predmemorije aplikacije"</string>
    <string name="permdesc_clearAppCache" product="tablet" msgid="8974640871945434565">"Aplikacija može osloboditi prostor za pohranu na tabletnom računalu brisanjem datoteka u direktorijima predmemorije drugih aplikacija. Time može uzrokovati sporije pokretanje drugih aplikacija jer one moraju ponovo dohvaćati svoje podatke."</string>
    <string name="permdesc_clearAppCache" product="default" msgid="2459441021956436779">"Aplikacija može osloboditi prostor za pohranu na telefonu brisanjem datoteka u direktorijima predmemorije drugih aplikacija. Time može uzrokovati sporije pokretanje drugih aplikacija jer one moraju ponovo dohvaćati svoje podatke."</string>
    <string name="permlab_movePackage" msgid="3289890271645921411">"premještanje resursa aplikacije"</string>
    <string name="permdesc_movePackage" msgid="319562217778244524">"Omogućuje aplikaciji premještanje izvora aplikacije s unutarnjih na vanjske medije i obrnuto."</string>
    <string name="permlab_readLogs" msgid="6615778543198967614">"čitaj osjetljive podatke dnevnika"</string>
    <string name="permdesc_readLogs" product="tablet" msgid="82061313293455151">"Aplikaciji omogućuje čitanje raznih sistemskih datoteka dnevnika. Tako može otkriti opće informacije o tome što radite na tabletnom računalu, što potencijalno uključuje osobne ili privatne informacije."</string>
    <string name="permdesc_readLogs" product="default" msgid="2063438140241560443">"Aplikaciji omogućuje čitanje raznih sistemskih datoteka zapisnika. Tako može otkriti opće informacije o tome što radite na telefonu, što potencijalno uključuje osobne ili privatne informacije."</string>
    <string name="permlab_anyCodecForPlayback" msgid="715805555823881818">"upotrijebi bilo koji dekoder za reprodukciju"</string>
    <string name="permdesc_anyCodecForPlayback" msgid="8283912488433189010">"Aplikaciji omogućuje korištenje bilo kojim instaliranim dekoderom medija za dekodiranje radi reprodukcije."</string>
    <string name="permlab_manageCaCertificates" msgid="1678391896786882014">"upravljanje pouzdanim vjerodajnicama"</string>
    <string name="permdesc_manageCaCertificates" msgid="4015644047196937014">"Omogućuje aplikaciji instaliranje i deinstaliranje CA certifikata kao pouzdanih vjerodajnica."</string>
    <string name="permlab_bindJobService" msgid="3637568367978271086">"izvršavaj planirani rad aplikacije u pozadini"</string>
    <string name="permdesc_bindJobService" msgid="3473288460524119838">"To dopuštenje omogućuje sustavu Android izvođenje aplikacije u pozadini na zahtjev."</string>
    <string name="permlab_diagnostic" msgid="8076743953908000342">"pisanje/čitanje u resursima čije je vlasnik dijagnostika"</string>
    <string name="permdesc_diagnostic" msgid="6608295692002452283">"Aplikaciji omogućuje čitanje i pisanje na bilo koji resurs u vlasništvu dijag. grupe; na primjer, datoteke u sustavu /dev. To bi moglo utjecati na stabilnost sustava i sigurnost. Dozvolu bi trebao upotrebljavati proizvođač ili operater SAMO za dijagnostiku koja se odnosi na hardver."</string>
    <string name="permlab_changeComponentState" msgid="6335576775711095931">"omogućavanje ili onemogućavanje komponenti aplikacije"</string>
    <string name="permdesc_changeComponentState" product="tablet" msgid="8887435740982237294">"Omogućuje aplikaciji da promijeni hoće li komponenta neke druge aplikacije biti omogućena ili neće. Zlonamjerne aplikacije mogu to upotrijebiti da bi onemogućile važne mogućnosti tabletnog računala. Treba biti oprezan s tom dozvolom jer je moguće dovesti komponente aplikacija u neupotrebljivo, nedosljedno ili nestabilno stanje."</string>
    <string name="permdesc_changeComponentState" product="default" msgid="1827232484416505615">"Omogućuje aplikaciji da promijeni hoće li komponenta neke druge aplikacije biti omogućena. Zlonamjerne aplikacije mogu to upotrijebiti da bi onemogućile važne mogućnosti telefona. Treba biti oprezan s tom dozvolom jer je moguće dovesti komponente aplikacija u neupotrebljivo, nedosljedno ili nestabilno stanje."</string>
    <string name="permlab_grantRevokePermissions" msgid="4627315351093508795">"dati ili oduzeti dopuštenja"</string>
    <string name="permdesc_grantRevokePermissions" msgid="4088642654085850662">"Aplikaciji omogućuje da odobri ili odbije određena dopuštenja za sebe ili druge aplikacije. Zlonamjerne aplikacije to mogu upotrijebiti za pristup značajkama za koje im niste odobrili pristup."</string>
    <string name="permlab_setPreferredApplications" msgid="8463181628695396391">"postavljanje željenih aplikacija"</string>
    <string name="permdesc_setPreferredApplications" msgid="4973986762241783712">"Omogućuje aplikaciji promjenu vaših željenih aplikacija. Zlonamjerne aplikacije mogu potajno promijeniti aplikacije koje su pokrenute, zavaravajući vaše postojeće aplikacije kako bi prikupljale privatne podatke od vas."</string>
    <string name="permlab_writeSettings" msgid="2226195290955224730">"izmjena postavki sustava"</string>
    <string name="permdesc_writeSettings" msgid="7775723441558907181">"Omogućuje aplikaciji izmjenu podataka postavki sustava. Zlonamjerne aplikacije mogu oštetiti konfiguraciju sustava."</string>
    <string name="permlab_writeSecureSettings" msgid="204676251876718288">"izmjena postavki sigurnosti sustava"</string>
    <string name="permdesc_writeSecureSettings" msgid="8159535613020137391">"Omogućuje aplikaciji izmjenu podataka sigurnosnih postavki sustava. Nije namijenjena uobičajenim aplikacijama."</string>
    <string name="permlab_writeGservices" msgid="2149426664226152185">"izmjena karte Google usluga"</string>
    <string name="permdesc_writeGservices" msgid="1287309437638380229">"Aplikaciji omogućuje izmjenu karte Googleovih usluga. Nije namijenjena uobičajenim aplikacijama."</string>
    <string name="permlab_receiveBootCompleted" msgid="5312965565987800025">"izvršavanje pri pokretanju"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="7390304664116880704">"Omogućuje aplikaciji da se sama pokrene čim sustav završi s pokretanjem. To može produljiti pokretanje tabletnog računala i omogućiti aplikaciji da općenito uspori tabletno računalo svojim neprekidnim izvršavanjem."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="513950589102617504">"Omogućuje aplikaciji da se sama pokrene čim sustav završi s pokretanjem. To može produljiti pokretanje telefona i omogućiti aplikaciji da općenito uspori telefon svojim neprekidnim izvršavanjem."</string>
    <string name="permlab_broadcastSticky" msgid="7919126372606881614">"slanje privlačnih prijenosa"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="7749760494399915651">"Aplikaciji omogućuje slanje \"ljepljivih\" emitiranja koja se zadržavaju nakon završetka emitiranja. Prekomjerna upotreba može usporiti tabletno računalo ili ga učiniti nestabilnim uzrokujući pretjeranu upotrebu memorije."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="2825803764232445091">"Aplikaciji omogućuje slanje \"ljepljivih\" emitiranja koja se zadržavaju nakon završetka emitiranja. Prekomjerna upotreba može usporiti telefon ili ga učiniti nestabilnim uzrokujući pretjeranu upotrebu memorije."</string>
    <string name="permlab_readContacts" msgid="8348481131899886131">"čitanje kontakata"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="5294866856941149639">"Aplikaciji omogućuje čitanje podataka o vašim kontaktima pohranjenim na tabletnom računalu, uključujući učestalost poziva, e-poruka ili drugih načina komunikacije s određenim pojedincima. Ta dozvola aplikaciji omogućuje spremanje podataka kontakata, a zlonamjerne aplikacije mogu dijeliti podatke kontakata bez vašeg znanja."</string>
    <string name="permdesc_readContacts" product="default" msgid="8440654152457300662">"Aplikaciji omogućuje čitanje podataka o vašim kontaktima pohranjenim na telefonu, uključujući učestalost poziva, e-poruka ili drugih načina komunikacije s određenim pojedincima. Ta dozvola aplikaciji omogućuje spremanje podataka kontakata, a zlonamjerne aplikacije mogu dijeliti podatke kontakata bez vašeg znanja."</string>
    <string name="permlab_writeContacts" msgid="5107492086416793544">"izmjena kontakata"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="897243932521953602">"Aplikaciji omogućuje izmjenu podataka o vašim kontaktima pohranjenim na tabletnom računalu, uključujući učestalost poziva, e-poruka ili drugih načina komunikacije s određenim kontaktima. Ta dozvola aplikacijama omogućuje brisanje kontaktnih podataka."</string>
    <string name="permdesc_writeContacts" product="default" msgid="589869224625163558">"Aplikaciji omogućuje izmjenu podataka o vašim kontaktima pohranjenim na telefonu, uključujući učestalost poziva, e-poruka ili drugih načina komunikacije s određenim kontaktima. Ta dozvola aplikacijama omogućuje brisanje kontaktnih podataka."</string>
    <string name="permlab_readCallLog" msgid="3478133184624102739">"čitanje dnevnika poziva"</string>
    <string name="permdesc_readCallLog" product="tablet" msgid="3700645184870760285">"Aplikaciji omogućuje čitanje zapisnika poziva vašeg tabletnog računala, uključujući podatke o dolaznim i odlaznim pozivima. Ta dozvola aplikacijama omogućuje spremanje podataka zapisnika poziva, a zlonamjerne aplikacije mogu dijeliti podatke zapisnika poziva bez vašeg znanja."</string>
    <string name="permdesc_readCallLog" product="default" msgid="5777725796813217244">"Aplikaciji omogućuje čitanje zapisnika poziva vašeg telefona, uključujući podatke o dolaznim i odlaznim pozivima. Ta dozvola aplikacijama omogućuje spremanje podataka zapisnika poziva, a zlonamjerne aplikacije mogu dijeliti podatke zapisnika poziva bez vašeg znanja."</string>
    <string name="permlab_writeCallLog" msgid="8552045664743499354">"pisanje u dnevnik poziva"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="6661806062274119245">"Aplikaciji omogućuje izmjenu dnevnika poziva vašeg tabletnog računala zajedno s podacima o dolaznim i odlaznim pozivima. Zlonamjerne aplikacije to mogu upotrebljavati za brisanje ili izmjenu vašeg dnevnika poziva."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="683941736352787842">"Aplikaciji omogućuje izmjenu dnevnika poziva vašeg telefona zajedno s podacima o dolaznim i odlaznim pozivima. Zlonamjerne aplikacije to mogu upotrebljavati za brisanje ili izmjenu vašeg dnevnika poziva."</string>
    <string name="permlab_readProfile" msgid="4701889852612716678">"čitanje vaše kontaktne kartice"</string>
    <string name="permdesc_readProfile" product="default" msgid="5462475151849888848">"Aplikaciji omogućuje čitanje osobnih podataka profila pohranjenih na uređaju, kao što su vaše ime ili kontaktni podaci. To znači da vas aplikacija može identificirati i slati informacije s vašeg profila drugima."</string>
    <string name="permlab_writeProfile" msgid="907793628777397643">"izmjena vaše kontaktne kartice"</string>
    <string name="permdesc_writeProfile" product="default" msgid="5552084294598465899">"Aplikaciji omogućuje promjenu ili dodavanje osobnih podataka profila pohranjenih na uređaju, kao što su vaše ime i kontaktni podaci. To znači da vas aplikacija može identificirati i slati informacije s vašeg profila drugima."</string>
    <string name="permlab_bodySensors" msgid="4871091374767171066">"senzori tjelesnih funkcija (npr. monitori otkucaja srca)"</string>
    <string name="permdesc_bodySensors" product="default" msgid="2998865085124153531">"Aplikaciji omogućuje pristup podacima iz senzora koje upotrebljavate za mjerenje onoga što se odvija u vašem tijelu, poput otkucaja srca."</string>
    <string name="permlab_readSocialStream" product="default" msgid="1268920956152419170">"čitanje društvenog streama"</string>
    <string name="permdesc_readSocialStream" product="default" msgid="4255706027172050872">"Aplikaciji omogućuje pristup vašim ažuriranjima na društvenim mrežama i ažuriranjima vaših prijatelja, kao i sinkronizaciju tih ažuriranja. Budite oprezni kad dijelite informacije – to aplikaciji omogućuje čitanje poruka između vas i vaših prijatelja na društvenim mrežama, neovisno o povjerljivosti. Napomena: ta se dozvola možda ne primjenjuje na svim društvenim mrežama."</string>
    <string name="permlab_writeSocialStream" product="default" msgid="3504179222493235645">"pisanje društvenog streama"</string>
    <string name="permdesc_writeSocialStream" product="default" msgid="3086557552204114849">"Aplikaciji omogućuje prikazivanje ažuriranja vaših prijatelja na društvenim mrežama. Budite oprezni kad dijelite informacije – to aplikaciji omogućuje stvaranje poruka koje mogu izgledati kao da dolaze od prijatelja. Napomena: ta se dozvola možda ne primjenjuje na svim društvenim mrežama."</string>
    <string name="permlab_readCalendar" msgid="5972727560257612398">"čitajte kalendarske događaje i povjerljive informacije"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="4216462049057658723">"Aplikaciji omogućuje čitanje svih događaja u kalendaru pohranjenih na vašem tabletnom računalu, uključujući one od vaših prijatelja ili suradnika. To aplikaciji može omogućiti dijeljenje ili spremanje vaših podataka kalendara, neovisno o povjerljivosti ili osjetljivosti."</string>
    <string name="permdesc_readCalendar" product="default" msgid="7434548682470851583">"Aplikaciji omogućuje čitanje svih događaja u kalendaru pohranjenih na vašem telefonu, uključujući one od vaših prijatelja ili suradnika. To aplikaciji može omogućiti dijeljenje ili spremanje vaših podataka kalendara, neovisno o povjerljivosti ili osjetljivosti."</string>
    <string name="permlab_writeCalendar" msgid="8438874755193825647">"dodajte ili izmijenite kalendarske događaje i pošaljite e-poštu gostima bez znanja vlasnika"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="6679035520113668528">"Aplikaciji omogućuje dodavanje, uklanjanje i promjenu događaja koje možete izmijeniti na tabletnom računalu, uključujući one od vaših prijatelja ili suradnika. To aplikaciji može omogućiti slanje poruka koje izgledaju kao da dolaze od vlasnika kalendara ili izmjenu događaja bez znanja vlasnika."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="2324469496327249376">"Aplikaciji omogućuje dodavanje, uklanjanje i promjenu događaja koje možete izmijeniti na telefonu, uključujući one od vaših prijatelja ili suradnika. To aplikaciji može omogućiti slanje poruka koje izgledaju kao da dolaze od vlasnika kalendara ili izmjenu događaja bez znanja vlasnika."</string>
    <string name="permlab_accessMockLocation" msgid="8688334974036823330">"omogućeno testiranje izvora lokacije"</string>
    <string name="permdesc_accessMockLocation" msgid="5808711039482051824">"Stvaranje lažnih izvora lokacije radi testiranja ili za instaliranje novog pružatelja usluga lokacije. To aplikaciji omogućuje zaobilaženje lokacije i/ili statusa koji vraćaju drugi izvori lokacije, primjerice GPS ili pružatelji usluga lokacije."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"pristup dodatnim naredbama davatelja lokacije"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="6078307221056649927">"Omogućuje aplikaciji pristup dodatnim naredbama davatelja usluga lokacije. To može omogućiti aplikaciji ometanje rada GPS-a ili drugih izvora lokacije."</string>
    <string name="permlab_installLocationProvider" msgid="6578101199825193873">"dopuštenje za instaliranje davatelja usluge lociranja"</string>
    <string name="permdesc_installLocationProvider" msgid="9066146120470591509">"Stvaranje lažnih izvora lokacije radi testiranja ili za instaliranje novog pružatelja usluga lokacije. To aplikaciji omogućuje zaobilaženje lokacije i/ili statusa koji vraćaju drugi izvori lokacije, primjerice GPS ili pružatelji usluga lokacije."</string>
    <string name="permlab_accessFineLocation" msgid="1191898061965273372">"precizna lokacija (GPS i mreža)"</string>
    <string name="permdesc_accessFineLocation" msgid="5295047563564981250">"Aplikacija može dobiti vašu preciznu lokaciju pomoću globalnog pozicijskog sustava (GPS-a) ili mrežnih izvora lokacije kao što su bazne stanice i Wi-Fi. Te lokacijske usluge moraju biti uključene i dostupne vašem uređaju da bi ih aplikacija mogla upotrebljavati. Aplikacije mogu upotrebljavati tu mogućnost kako bi utvrdile vašu lokaciju i mogu dodatno trošiti bateriju."</string>
    <string name="permlab_accessCoarseLocation" msgid="4887895362354239628">"približna lokacija (mreža)"</string>
    <string name="permdesc_accessCoarseLocation" msgid="2538200184373302295">"Aplikacija može dobiti vašu približnu lokaciju. Tu lokaciju izvode lokacijske usluge pomoću mrežnih izvora lokacije kao što su bazne stanice i Wi-Fi. Te lokacijske usluge moraju biti uključene i dostupne vašem uređaju da bi ih aplikacija mogla upotrebljavati. Aplikacije mogu upotrebljavati tu mogućnost kako bi utvrdile vašu približnu lokaciju."</string>
    <string name="permlab_accessSurfaceFlinger" msgid="2363969641792388947">"pristup značajci SurfaceFlinger"</string>
    <string name="permdesc_accessSurfaceFlinger" msgid="1041619516733293551">"Aplikaciji omogućuje upotrebu značajki niske razine SurfaceFlinger."</string>
    <string name="permlab_readFrameBuffer" msgid="6690504248178498136">"čitanje međuspremnika okvira"</string>
    <string name="permdesc_readFrameBuffer" msgid="4937405521809454680">"Aplikaciji omogućuje čitanje sadržaja međuspremnika okvira."</string>
    <string name="permlab_accessInputFlinger" msgid="5348635270689553857">"pristupi InputFlingeru"</string>
    <string name="permdesc_accessInputFlinger" msgid="2104864941201226616">"Dopušta aplikaciji upotrebu značajki niske razine InputFlingera."</string>
    <string name="permlab_configureWifiDisplay" msgid="5595661694746742168">"konfiguriraj Wifi zaslone"</string>
    <string name="permdesc_configureWifiDisplay" msgid="7916815158690218065">"Omogućuje aplikaciji konfiguriranje i povezivanje s Wi-Fi zaslonima."</string>
    <string name="permlab_controlWifiDisplay" msgid="393641276723695496">"upravljaj Wifi zaslonima"</string>
    <string name="permdesc_controlWifiDisplay" msgid="4543912292681826986">"Omogućuje aplikaciji upravljanje značajkama Wi-Fi zaslona niske razine."</string>
    <string name="permlab_captureAudioOutput" msgid="6857134498402346708">"primanje audioizlaza"</string>
    <string name="permdesc_captureAudioOutput" msgid="6210597754212208853">"Omogućuje aplikaciji primanje i preusmjeravanje audioizlaza."</string>
    <string name="permlab_captureAudioHotword" msgid="1890553935650349808">"Otkrivanje pokretača značajke"</string>
    <string name="permdesc_captureAudioHotword" msgid="9151807958153056810">"Aplikaciji omogućuje snimanje zvuka radi otkrivanja pokretača značajke. Snimanje se može odvijati u pozadini, ali ne sprječava drugo snimanje zvuka (npr. kameru)."</string>
    <string name="permlab_modifyAudioRouting" msgid="7738060354490807723">"Preusmjeravanje zvučnog zapisa"</string>
    <string name="permdesc_modifyAudioRouting" msgid="7205731074267199735">"Omogućuje aplikaciji izravno upravljanje preusmjeravanjem zvučnog zapisa i zaobilaženje odluka pravila o zvučnim zapisima."</string>
    <string name="permlab_captureVideoOutput" msgid="2246828773589094023">"primanje videoizlaza"</string>
    <string name="permdesc_captureVideoOutput" msgid="359481658034149860">"Omogućuje aplikaciji primanje i preusmjeravanje videoizlaza."</string>
    <string name="permlab_captureSecureVideoOutput" msgid="7815398969303382016">"primanje sigurnog videoizlaza"</string>
    <string name="permdesc_captureSecureVideoOutput" msgid="2779793064709350289">"Omogućuje aplikaciji primanje i preusmjeravanje sigurnog videoizlaza."</string>
    <string name="permlab_mediaContentControl" msgid="8749790560720562511">"upravljanje reprodukcijom medija i pristup metapodacima"</string>
    <string name="permdesc_mediaContentControl" msgid="1637478200272062">"Omogućuje aplikaciji upravljanje reprodukcijom medija i pristupanje podacima o medijima (naslov, autor...)."</string>
    <string name="permlab_modifyAudioSettings" msgid="6095859937069146086">"promjena postavki zvuka"</string>
    <string name="permdesc_modifyAudioSettings" msgid="3522565366806248517">"Aplikaciji omogućuje izmjenu globalnih postavki zvuka, primjerice glasnoće i zvučnika koji se upotrebljava za izlaz."</string>
    <string name="permlab_recordAudio" msgid="3876049771427466323">"snimanje zvuka"</string>
    <string name="permdesc_recordAudio" msgid="4906839301087980680">"Aplikaciji omogućuje snimanje zvuka mikrofonom. Ta dozvola aplikaciji omogućuje snimanje zvuka u bilo kojem trenutku bez vašeg odobrenja."</string>
    <string name="permlab_sim_communication" msgid="1180265879464893029">"komunikacija sa SIM-om"</string>
    <string name="permdesc_sim_communication" msgid="5725159654279639498">"Omogućuje aplikaciji slanje naredbi SIM-u. To je vrlo opasno."</string>
    <string name="permlab_camera" msgid="3616391919559751192">"snimi fotografije i videozapise"</string>
    <string name="permdesc_camera" msgid="8497216524735535009">"Aplikaciji omogućuje snimanje slika i videozapisa fotoaparatom. Ta dozvola aplikaciji omogućuje upotrebu fotoaparata u bilo kojem trenutku bez vašeg odobrenja."</string>
    <string name="permlab_cameraDisableTransmitLed" msgid="2651072630501126222">"onemogućavanje lampice pokazivača prijenosa kada je fotoaparat u upotrebi"</string>
    <string name="permdesc_cameraDisableTransmitLed" msgid="4764585465480295341">"Omogućuje unaprijed instaliranim aplikacijama sustava onemogućavanje lampice pokazivača upotrebe fotoaparata."</string>
    <string name="permlab_brick" product="tablet" msgid="2961292205764488304">"trajno onemogući tabletni uređaj"</string>
    <string name="permlab_brick" product="default" msgid="8337817093326370537">"trajno onemogućavanje telefona"</string>
    <string name="permdesc_brick" product="tablet" msgid="4334818808001699530">"Aplikaciji omogućuje trajno isključivanje cijelog tabletnog računala. To je vrlo opasno."</string>
    <string name="permdesc_brick" product="default" msgid="5788903297627283099">"Aplikaciji omogućuje trajno isključivanje cijelog telefona. To je veoma opasno."</string>
    <string name="permlab_reboot" product="tablet" msgid="3436634972561795002">"prisilno ponovno pokretanje tabletnog uređaja"</string>
    <string name="permlab_reboot" product="default" msgid="2898560872462638242">"prisilno ponovno pokretanje telefona"</string>
    <string name="permdesc_reboot" product="tablet" msgid="8172056180063700741">"Aplikaciji omogućuje prisilno ponovno pokretanje tabletnog računala."</string>
    <string name="permdesc_reboot" product="default" msgid="5326008124289989969">"Aplikaciji omogućuje prisilno ponovno pokretanje telefona."</string>
    <string name="permlab_mount_unmount_filesystems" product="nosdcard" msgid="2927361537942591841">"pristupanje dat. sustavu USB-a"</string>
    <string name="permlab_mount_unmount_filesystems" product="default" msgid="4402305049890953810">"pristupanje datotečnom sustavu SD kartice"</string>
    <string name="permdesc_mount_unmount_filesystems" msgid="1829290701658992347">"Aplikaciji omogućuje instaliranje i deinstaliranje datotečnih sustava za prijenosnu pohranu."</string>
    <string name="permlab_mount_format_filesystems" product="nosdcard" msgid="6227819582624904972">"brisanje USB pohrane"</string>
    <string name="permlab_mount_format_filesystems" product="default" msgid="262582698639274056">"brisanje SD kartice"</string>
    <string name="permdesc_mount_format_filesystems" msgid="8784268246779198627">"Aplikaciji omogućuje formatiranje prijenosnog medija za pohranu."</string>
    <string name="permlab_asec_access" msgid="3411338632002193846">"dohvati informacije o unutarnjoj pohrani"</string>
    <string name="permdesc_asec_access" msgid="3094563844593878548">"Aplikaciji omogućuje dohvaćanje informacija o internoj pohrani."</string>
    <string name="permlab_asec_create" msgid="6414757234789336327">"stvori unutarnju pohranu"</string>
    <string name="permdesc_asec_create" msgid="4558869273585856876">"Aplikaciji omogućuje stvaranje interne pohrane."</string>
    <string name="permlab_asec_destroy" msgid="526928328301618022">"uništi unutarnju pohranu"</string>
    <string name="permdesc_asec_destroy" msgid="7218749286145526537">"Aplikaciji omogućuje uništavanje interne pohrane."</string>
    <string name="permlab_asec_mount_unmount" msgid="8877998101944999386">"instaliranje/deinstaliranje interne pohrane"</string>
    <string name="permdesc_asec_mount_unmount" msgid="3451360114902490929">"Aplikaciji omogućuje uključivanje/isključivanje interne pohrane."</string>
    <string name="permlab_asec_rename" msgid="7496633954080472417">"preimenuj unutarnju pohranu"</string>
    <string name="permdesc_asec_rename" msgid="1794757588472127675">"Aplikaciji omogućuje preimenovanje interne pohrane."</string>
    <string name="permlab_vibrate" msgid="7696427026057705834">"upravljanje vibracijom"</string>
    <string name="permdesc_vibrate" msgid="6284989245902300945">"Aplikaciji omogućuje nadzor nad vibratorom."</string>
    <string name="permlab_flashlight" msgid="2155920810121984215">"upravljanje svjetiljkom"</string>
    <string name="permdesc_flashlight" msgid="6522284794568368310">"Aplikaciji omogućuje upravljanje svjetiljkom."</string>
    <string name="permlab_manageUsb" msgid="1113453430645402723">"upravljanje postavkama i dozvolama za USB uređaje"</string>
    <string name="permdesc_manageUsb" msgid="7776155430218239833">"Aplikaciji omogućuje upravljanje postavkama i dozvolama za USB uređaje."</string>
    <string name="permlab_accessMtp" msgid="4953468676795917042">"Primjena MTP protokola"</string>
    <string name="permdesc_accessMtp" msgid="6532961200486791570">"Omogućuje pristup upravljačkom programu jezgre MTP-a radi implementacije MTP USB protokola."</string>
    <string name="permlab_hardware_test" msgid="4148290860400659146">"testiranje hardvera"</string>
    <string name="permdesc_hardware_test" msgid="6597964191208016605">"Aplikaciji omogućuje upravljanje raznim perifernim uređajima za potrebe ispitivanja hardvera."</string>
    <string name="permlab_fm" msgid="8749504526866832">"pristup FM radiju"</string>
    <string name="permdesc_fm" msgid="4145699441237962818">"Omogućuje aplikaciji pristup FM radiju radi slušanja programa."</string>
    <string name="permlab_callPhone" msgid="3925836347681847954">"izravno pozivanje telefonskog broja"</string>
    <string name="permdesc_callPhone" msgid="3740797576113760827">"Aplikaciji omogućuje pozivanje telefonskih brojeva bez vašeg sudjelovanja. To može dovesti do neočekivanih troškova ili poziva. Uzmite u obzir da se aplikaciji time ne omogućuje pozivanje brojeva u nuždi. Zlonamjerne aplikacije mogu vam uzrokovati dodatne troškove postavljanjem poziva bez vašeg odobrenja."</string>
    <string name="permlab_callPrivileged" msgid="4198349211108497879">"izravno pozivanje bilo kojeg telefonskog broja"</string>
    <string name="permdesc_callPrivileged" msgid="1689024901509996810">"Omogućuje aplikaciji pozivanje bilo kojeg telefonskog broja, uključujući hitne brojeve, bez vašeg uplitanja. Zlonamjerne aplikacije mogu upućivati nepotrebne i nezakonite pozive hitnim službama."</string>
    <string name="permlab_performCdmaProvisioning" product="tablet" msgid="4842576994144604821">"izravno pokreni postavljanje CDMA tabletnog uređaja"</string>
    <string name="permlab_performCdmaProvisioning" product="default" msgid="5604848095315421425">"izravno pokretanje postavke CDMA telefona"</string>
    <string name="permdesc_performCdmaProvisioning" msgid="1994193538802314186">"Aplikaciji omogućuje pokretanje dodjele CDMA. Zlonamjerne aplikacije mogu nepotrebno pokrenuti dodjelu CDMA."</string>
    <string name="permlab_locationUpdates" msgid="7785408253364335740">"obavijesti o ažuriranju kontrolne lokacije"</string>
    <string name="permdesc_locationUpdates" msgid="1120741557891438876">"Omogućuje aplikaciji omogućavanje/onemogućavanje obavijesti o ažuriranju lokacije s radija. Nije namijenjena uobičajenim aplikacijama."</string>
    <string name="permlab_checkinProperties" msgid="7855259461268734914">"pristup svojstvima prijave"</string>
    <string name="permdesc_checkinProperties" msgid="4024526968630194128">"Omogućuje aplikaciji pristup za čitanje/pisanje svojstvima prenesenima uslugom prijave. Nije namijenjena uobičajenim aplikacijama."</string>
    <string name="permlab_bindGadget" msgid="776905339015863471">"odabir widgeta"</string>
    <string name="permdesc_bindGadget" msgid="8261326938599049290">"Omogućuje aplikaciji da obavijesti sustav koje widgete može upotrebljavati koja aplikacija. Aplikacija s tom dozvolom može drugim aplikacijama dati pristup osobnim podacima. Nije namijenjena uobičajenim aplikacijama."</string>
    <string name="permlab_modifyPhoneState" msgid="8423923777659292228">"promjena stanja telefona"</string>
    <string name="permdesc_modifyPhoneState" msgid="1029877529007686732">"Omogućuje aplikaciji upravljanje telefonskim značajkama uređaja. Aplikacija s tom dozvolom može izmjenjivati mreže, uključiti i isključiti radiouređaj telefona i tome slično, a da vas o tome uopće ne obavijesti."</string>
    <string name="permlab_readPhoneState" msgid="9178228524507610486">"čitanje statusa i identiteta telefona"</string>
    <string name="permdesc_readPhoneState" msgid="1639212771826125528">"Aplikaciji omogućuje pristup telefonskim značajkama uređaja. Ta dozvola aplikaciji omogućuje utvrđivanje telefonskog broja i ID-ova uređaja, je li poziv aktivan te udaljeni broj koji je povezan pozivom."</string>
    <string name="permlab_readPrecisePhoneState" msgid="5476483020282007597">"čitaj precizna stanja telefona"</string>
    <string name="permdesc_readPrecisePhoneState" msgid="6648009074263855418">"Omogućuje aplikaciji pristup preciznim stanjima telefona. To dopuštenje omogućuje aplikaciji da odredi stvarni status poziva, je li poziv aktivan ili u pozadini, neuspjele pozive, precizne podatke o statusu veze te neuspjela uspostavljanja podatkovnih veza."</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1531731435011495015">"spriječi mirovanje tabletnog uređaja"</string>
    <string name="permlab_wakeLock" product="default" msgid="573480187941496130">"sprečava telefon da prijeđe u stanje mirovanja"</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="7311319824400447868">"Aplikaciji omogućuje sprječavanje prelaska tabletnog računala u mirovanje."</string>
    <string name="permdesc_wakeLock" product="default" msgid="8559100677372928754">"Aplikaciji omogućuje da spriječi prelazak telefona u mirovanje."</string>
    <string name="permlab_transmitIr" msgid="7545858504238530105">"infracrveni prijenos"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5358308854306529170">"Aplikaciji omogućuje upotrebu infracrvenog odašiljača tableta."</string>
    <string name="permdesc_transmitIr" product="default" msgid="7957763745020300725">"Aplikaciji omogućuje upotrebu infracrvenog odašiljača telefona."</string>
    <string name="permlab_devicePower" product="tablet" msgid="2787034722616350417">"uključivanje ili isključivanje tabletnog uređaja"</string>
    <string name="permlab_devicePower" product="default" msgid="4928622470980943206">"uključivanje ili isključivanje telefona"</string>
    <string name="permdesc_devicePower" product="tablet" msgid="6689862878984631831">"Aplikaciji omogućuje uključivanje i isključivanje tabletnog računala."</string>
    <string name="permdesc_devicePower" product="default" msgid="6037057348463131032">"Aplikaciji omogućuje uključivanje ili isključivanje telefona."</string>
    <string name="permlab_userActivity" msgid="1677844893921729548">"ponovno postavljanje vremena čekanja zaslona"</string>
    <string name="permdesc_userActivity" msgid="651746160252248024">"Omogućuje aplikaciji ponovno postavljanje vremena čekanja zaslona."</string>
    <string name="permlab_factoryTest" msgid="3715225492696416187">"pokretanje u tvorničkom testnom načinu rada"</string>
    <string name="permdesc_factoryTest" product="tablet" msgid="3952059318359653091">"Pokrenite kao niskorazinski proizvođački test, uz omogućavanje potpunog pristupa hardveru tabletnog uređaja. Dostupno je samo ako tabletni uređaj radi u proizvođačkom testnom načinu rada."</string>
    <string name="permdesc_factoryTest" product="default" msgid="8136644990319244802">"Pokrenite kao niskorazinski proizvođački test, uz omogućavanje potpunog pristupa telefonskom hardveru. Dostupno je samo ako telefon radi u proizvođačkom testnom načinu rada."</string>
    <string name="permlab_setWallpaper" msgid="6627192333373465143">"postavi pozadinu"</string>
    <string name="permdesc_setWallpaper" msgid="7373447920977624745">"Aplikaciji omogućuje postavljanje pozadinskih slika sustava."</string>
    <string name="permlab_setWallpaperHints" msgid="3278608165977736538">"prilagođavanje veličine pozadinske slike"</string>
    <string name="permdesc_setWallpaperHints" msgid="8235784384223730091">"Aplikaciji omogućuje postavljanje savjeta za veličinu sistemske pozadinske slike."</string>
    <string name="permlab_masterClear" msgid="2315750423139697397">"poništavanje sustava na tvornički zadane postavke"</string>
    <string name="permdesc_masterClear" msgid="3665380492633910226">"Omogućuje aplikaciji potpuno vraćanje sustava na tvorničke postavke čime se brišu svi podaci, konfiguracija i instalirane aplikacije."</string>
    <string name="permlab_setTime" msgid="2021614829591775646">"postavljanje vremena"</string>
    <string name="permdesc_setTime" product="tablet" msgid="1896341438151152881">"Aplikaciji omogućuje promjenu vremena na satu tabletnog računala."</string>
    <string name="permdesc_setTime" product="default" msgid="1855702730738020">"Aplikaciji omogućuje promjenu vremena na satu telefona."</string>
    <string name="permlab_setTimeZone" msgid="2945079801013077340">"postavljanje vremenske zone"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1676983712315827645">"Aplikaciji omogućuje promjenu vremenske zone na tabletnom računalu."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4499943488436633398">"Aplikaciji omogućuje promjenu vremenske zone na telefonu."</string>
    <string name="permlab_accountManagerService" msgid="4829262349691386986">"ima ulogu Usluge voditelja računa"</string>
    <string name="permdesc_accountManagerService" msgid="1948455552333615954">"Aplikaciji omogućuje pozivanje ovjerovitelja računa AccountAuthenticators."</string>
    <string name="permlab_getAccounts" msgid="1086795467760122114">"pronalaženje računa na uređaju"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="2741496534769660027">"Aplikaciji omogućuje dobivanje popisa računa koje tabletno računalo poznaje. Uključeni mogu biti svi računi koje izrade aplikacije koje ste instalirali."</string>
    <string name="permdesc_getAccounts" product="default" msgid="3448316822451807382">"Aplikaciji omogućuje dobivanje popisa računa koje telefon poznaje. Uključeni mogu biti svi računi koje izrade aplikacije koje ste instalirali."</string>
    <string name="permlab_authenticateAccounts" msgid="5265908481172736933">"stvaranje računa i postavljenje zaporki"</string>
    <string name="permdesc_authenticateAccounts" msgid="5472124296908977260">"Aplikaciji omogućuje upotrebu mogućnosti AccountManagera za autentifikaciju računa, uključujući stvaranje računa te dobivanje i postavljanje njihovih zaporki."</string>
    <string name="permlab_manageAccounts" msgid="4983126304757177305">"dodavanje ili uklanjanje računa"</string>
    <string name="permdesc_manageAccounts" msgid="8698295625488292506">"Aplikaciji omogućuje obavljanje operacija kao što su dodavanje i uklanjanje računa i brisanje zaporke."</string>
    <string name="permlab_useCredentials" msgid="235481396163877642">"upotreba računa na uređaju"</string>
    <string name="permdesc_useCredentials" msgid="7984227147403346422">"Aplikaciji omogućuje traženje oznaka za autentifikaciju."</string>
    <string name="permlab_accessNetworkState" msgid="4951027964348974773">"prikaz mrežnih veza"</string>
    <string name="permdesc_accessNetworkState" msgid="8318964424675960975">"Aplikaciji omogućuje pregled informacija o mrežnim vezama, primjerice koje mreže postoje i koje su spojene."</string>
    <string name="permlab_createNetworkSockets" msgid="8018758136404323658">"puni mrežni pristup"</string>
    <string name="permdesc_createNetworkSockets" msgid="3403062187779724185">"Aplikaciji omogućuje stvaranje mrežnih utičnica i upotrebu prilagođenih mrežnih protokola. Preglednik i druge aplikacije pružaju sredstva za slanje podataka na internet, tako da ta dozvola nije potrebna za slanje podataka na internet."</string>
    <string name="permlab_writeApnSettings" msgid="505660159675751896">"promjena/presretanje mrežnih postavki i prometa"</string>
    <string name="permdesc_writeApnSettings" msgid="5333798886412714193">"Omogućuje aplikaciji promjenu postavki mreže te presretanje i pregledavanje kompletnog mrežnog prometa, na primjer, radi promjene proxy poslužitelja i priključka bilo kojeg APN-a. Zlonamjerne aplikacije mogu nadzirati, preusmjeravati ili mijenjati mrežne pakete bez vašeg znanja."</string>
    <string name="permlab_changeNetworkState" msgid="958884291454327309">"promjena mrežne povezivosti"</string>
    <string name="permdesc_changeNetworkState" msgid="6789123912476416214">"Aplikaciji omogućuje promjenu stanja mrežnog povezivanja."</string>
    <string name="permlab_changeTetherState" msgid="5952584964373017960">"promjena modemskog povezivanja"</string>
    <string name="permdesc_changeTetherState" msgid="1524441344412319780">"Aplikaciji omogućuje promjenu stanja modemskog mrežnog povezivanja."</string>
    <string name="permlab_changeBackgroundDataSetting" msgid="1400666012671648741">"promjena postavke upotrebe pozadinskih podataka"</string>
    <string name="permdesc_changeBackgroundDataSetting" msgid="5347729578468744379">"Aplikaciji omogućuje promjenu postavke za upotrebu pozadinskih podataka."</string>
    <string name="permlab_accessWifiState" msgid="5202012949247040011">"prikaz Wi-Fi veza"</string>
    <string name="permdesc_accessWifiState" msgid="5002798077387803726">"Aplikaciji omogućuje pregled informacija o Wi-Fi mrežama, primjerice, je li Wi-Fi omogućen i naziv spojenih Wi-Fi uređaja."</string>
    <string name="permlab_changeWifiState" msgid="6550641188749128035">"uspostavljanje i prekidanje veze s Wi-Fi mrežom"</string>
    <string name="permdesc_changeWifiState" msgid="7137950297386127533">"Aplikaciji omogućuje spajanje na Wi-Fi pristupne točke i prekidanje veze s njima te promjenu konfiguracije uređaja za Wi-Fi mreže."</string>
    <string name="permlab_changeWifiMulticastState" msgid="1368253871483254784">"omogući višenamjenski Wi-Fi prijem"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="7969774021256336548">"Aplikaciji omogućuje primanje paketa poslanih na sve uređaje na Wi-Fi mreži putem adresa za višesmjerno slanje, ne samo na vaše tabletno računalo. Potrošnja struje veća je nego u načinu bez višesmjernog slanja."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="6851949706025349926">"Aplikaciji omogućuje primanje paketa poslanih na sve uređaje na Wi-Fi mreži putem adresa za višesmjerno slanje, ne samo na vaš telefon. Potrošnja struje veća je nego u načinu bez višesmjernog slanja."</string>
    <string name="permlab_bluetoothAdmin" msgid="6006967373935926659">"pristupanje postavkama Bluetootha"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="6921177471748882137">"Aplikaciji omogućuje konfiguraciju lokalnog tabletnog računala s Bluetoothom te otkrivanje i uparivanje s udaljenim  uređajima."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="8931682159331542137">"Aplikaciji omogućuje konfiguraciju lokalnog Bluetooth telefona i otkrivanje i uparivanje s udaljenim uređajima."</string>
    <string name="permlab_bluetoothPriv" msgid="4009494246009513828">"omogući aplikaciji uparivanje putem Bluetootha"</string>
    <string name="permdesc_bluetoothPriv" product="tablet" msgid="8045735193417468857">"Aplikaciji se omogućuje uparivanje s udaljenim uređajima bez interakcije korisnika."</string>
    <string name="permdesc_bluetoothPriv" product="default" msgid="8045735193417468857">"Aplikaciji se omogućuje uparivanje s udaljenim uređajima bez interakcije korisnika."</string>
    <string name="permlab_bluetoothMap" msgid="6372198338939197349">"pristup podacima Bluetooth MAP-a"</string>
    <string name="permdesc_bluetoothMap" product="tablet" msgid="5784090105926959958">"Omogućuje aplikaciji pristup podacima Bluetooth MAP-a."</string>
    <string name="permdesc_bluetoothMap" product="default" msgid="5784090105926959958">"Omogućuje aplikaciji pristup podacima Bluetooth MAP-a."</string>
    <string name="permlab_accessWimaxState" msgid="4195907010610205703">"uspostavljanje i prekidanje veze s WiMAX-om"</string>
    <string name="permdesc_accessWimaxState" msgid="6360102877261978887">"Aplikaciji omogućuje utvrđivanje omogućenosti WiMAX mreže te daje informaciju o tome je li spojena neka WiMAX mreža."</string>
    <string name="permlab_changeWimaxState" msgid="2405042267131496579">"Promjena stanja WiMAX mreže"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="3156456504084201805">"Aplikaciji omogućuje povezivanje tabletnog računala s WiMAX mrežama i prekidanje veze tabletnog računala s njima."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="697025043004923798">"Aplikaciji omogućuje povezivanje telefona s WiMAX mrežama i prekidanje veze telefona s njima."</string>
    <string name="permlab_scoreNetworks" msgid="6445777779383587181">"ocjenjivanje mreža"</string>
    <string name="permdesc_scoreNetworks" product="tablet" msgid="1304304745850215556">"Aplikaciji omogućuje rangiranje mreža i utjecanje na odabir preferiranih mreža na tabletu."</string>
    <string name="permdesc_scoreNetworks" product="default" msgid="1831501848178651379">"Aplikaciji omogućuje rangiranje mreža i utjecanje na odabir preferiranih mreža na telefonu."</string>
    <string name="permlab_bluetooth" msgid="6127769336339276828">"uparivanje s Bluetooth uređajima"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3480722181852438628">"Aplikaciji omogućuje pregled konfiguracije Bluetootha na tabletnom računalu te uspostavljanje i prihvaćanje veza s uparenim uređajima."</string>
    <string name="permdesc_bluetooth" product="default" msgid="3207106324452312739">"Aplikaciji omogućuje pregled konfiguracije Bluetootha na telefonu te uspostavljanje i prihvaćanje veza s uparenim uređajima."</string>
    <string name="permlab_nfc" msgid="4423351274757876953">"upravljanje beskontaktnom komunikacijom (NFC)"</string>
    <string name="permdesc_nfc" msgid="7120611819401789907">"Aplikaciji omogućuje komunikaciju s oznakama, karticama i čitačima komunikacije kratkog dometa (NFC)."</string>
    <string name="permlab_disableKeyguard" msgid="3598496301486439258">"onemogućavanje zaključavanja zaslona"</string>
    <string name="permdesc_disableKeyguard" msgid="6034203065077122992">"Aplikaciji omogućuje onemogućavanje zaključavanja tipkovnice i svih pripadajućih sigurnosnih zaporki. Na primjer, telefon onemogućuje zaključavanje tipkovnice kod primanja dolaznog telefonskog poziva, nakon kojeg se zaključavanje tipkovnice ponovo omogućuje."</string>
    <string name="permlab_readSyncSettings" msgid="6201810008230503052">"čitanje postavki sinkronizacije"</string>
    <string name="permdesc_readSyncSettings" msgid="2706745674569678644">"Aplikaciji omogućuje čitanje postavki sinkronizacije za račun. Time se, primjerice, može utvrditi je li aplikacija Osobe sinkronizirana s računom."</string>
    <string name="permlab_writeSyncSettings" msgid="5408694875793945314">"uključivanje/isključivanje sinkronizacije"</string>
    <string name="permdesc_writeSyncSettings" msgid="8956262591306369868">"Aplikaciji omogućuje izmjenu postavki sinkronizacije za račun. Na primjer, to se može upotrijebiti za omogućavanje sinkronizacije aplikacije Osobe s računom."</string>
    <string name="permlab_readSyncStats" msgid="7396577451360202448">"čitanje statistike o sinkronizaciji"</string>
    <string name="permdesc_readSyncStats" msgid="1510143761757606156">"Aplikaciji omogućuje čitanje statistika sinkronizacije za račun, uključujući povijest sinkronizacije te količinu sinkroniziranih podataka."</string>
    <string name="permlab_subscribedFeedsRead" msgid="4756609637053353318">"čitanje pretplaćenih feedova"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="5557058907906144505">"Aplikaciji omogućuje dohvaćanje detalja o trenutačno sinkroniziranim feedovima."</string>
    <string name="permlab_subscribedFeedsWrite" msgid="9015246325408209296">"pisanje pretplaćenih feedova"</string>
    <string name="permdesc_subscribedFeedsWrite" msgid="6928930188826089413">"Omogućuje aplikaciji promjenu vaših trenutačno sinkroniziranih feedova. Zlonamjerne aplikacije mogu promijeniti vaše sinkronizirane feedove."</string>
    <string name="permlab_readDictionary" msgid="4107101525746035718">"čitanje pojmova koje ste dodali u rječnik"</string>
    <string name="permdesc_readDictionary" msgid="659614600338904243">"Aplikaciji omogućuje čitanje svih riječi, imena i fraza koje je korisnik pohranio u korisničkom rječniku."</string>
    <string name="permlab_writeDictionary" msgid="2183110402314441106">"dodavanje riječi u rječnik koji je izradio korisnik"</string>
    <string name="permdesc_writeDictionary" msgid="8185385716255065291">"Aplikaciji omogućuje pisanje novih riječi u korisnički rječnik."</string>
    <string name="permlab_sdcardRead" product="nosdcard" msgid="367275095159405468">"čitanje sadržaja USB pohrane"</string>
    <string name="permlab_sdcardRead" product="default" msgid="2188156462934977940">"čitanje sadržaja SD kartice"</string>
    <string name="permdesc_sdcardRead" product="nosdcard" msgid="3446988712598386079">"Aplikaciji omogućuje čitanje sadržaja vaše USB pohrane."</string>
    <string name="permdesc_sdcardRead" product="default" msgid="2607362473654975411">"Aplikaciji omogućuje čitanje sadržaja vaše SD kartice."</string>
    <string name="permlab_sdcardWrite" product="nosdcard" msgid="8485979062254666748">"izmjena/brisanje sadržaja USB-a"</string>
    <string name="permlab_sdcardWrite" product="default" msgid="8805693630050458763">"izmjena ili brisanje sadržaja SD kartice"</string>
    <string name="permdesc_sdcardWrite" product="nosdcard" msgid="6175406299445710888">"Dopušta pisanje u USB pohranu."</string>
    <string name="permdesc_sdcardWrite" product="default" msgid="4337417790936632090">"Aplikaciji omogućuje pisanje na SD karticu."</string>
    <string name="permlab_mediaStorageWrite" product="default" msgid="6859839199706879015">"izmijeni/izbriši sadržaj pohranjen na internim medijima"</string>
    <string name="permdesc_mediaStorageWrite" product="default" msgid="8189160597698529185">"Aplikaciji omogućuje izmjenu sadržaja pohranjenog na internim medijima."</string>
    <string name="permlab_manageDocs" product="default" msgid="5778318598448849829">"upravljanje pohr. dokumenata"</string>
    <string name="permdesc_manageDocs" product="default" msgid="8704323176914121484">"Omogućuje aplikaciji upravljanje pohranom dokumenata."</string>
    <string name="permlab_sdcardAccessAll" msgid="8150613823900460576">"pristup vanjskoj pohrani svima"</string>
    <string name="permdesc_sdcardAccessAll" msgid="3215208357415891320">"Omogućuje aplikaciji pristup vanjskoj pohrani za sve korisnike."</string>
    <string name="permlab_cache_filesystem" msgid="5656487264819669824">"pristup sustavu datoteka predmemorije"</string>
    <string name="permdesc_cache_filesystem" msgid="5578967642265550955">"Aplikaciji omogućuje čitanje i pisanje u datotečnom sustavu privremene memorije."</string>
    <string name="permlab_use_sip" msgid="2052499390128979920">"upućivanje/primanje SIP poziva"</string>
    <string name="permdesc_use_sip" msgid="2297804849860225257">"Aplikacija može upućivati i primati SIP pozive."</string>
    <string name="permlab_bind_incall_service" msgid="6773648341975287125">"interakcija sa zaslonom tijekom poziva"</string>
    <string name="permdesc_bind_incall_service" msgid="8343471381323215005">"Omogućuje aplikaciji upravljanje vremenom i načinom na koji se korisniku prikazuje zaslon tijekom poziva."</string>
    <string name="permlab_bind_connection_service" msgid="3557341439297014940">"interakcija s telefonskim uslugama"</string>
    <string name="permdesc_bind_connection_service" msgid="4008754499822478114">"Omogućuje aplikacijama interakciju s telefonskim uslugama za uspostavljanje i primanje poziva."</string>
    <string name="permlab_control_incall_experience" msgid="9061024437607777619">"pružanje korisničkog iskustva tijekom poziva"</string>
    <string name="permdesc_control_incall_experience" msgid="915159066039828124">"Omogućuje aplikaciji pružanje korisničkog iskustva tijekom poziva."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="7862593283611493232">"čitanje povijesti upotrebe mreže"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="7689060749819126472">"Aplikaciji omogućuje čitanje povijesti upotrebe mreže za određene mreže i aplikacije."</string>
    <string name="permlab_manageNetworkPolicy" msgid="2562053592339859990">"Upravljanje mrežnim pravilima"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="7537586771559370668">"Aplikaciji omogućuje upravljanje mrežnim pravilima i određivanje pravila za aplikacije."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="5088217309088729650">"izmjena evidencije mrežne upotrebe"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5443412866746198123">"Omogućuje aplikaciji izmjenu načina upotrebe mreže u odnosu na aplikacije. Nije namijenjeno uobičajenim aplikacijama."</string>
    <string name="permlab_accessNotifications" msgid="7673416487873432268">"pristup obavijestima"</string>
    <string name="permdesc_accessNotifications" msgid="458457742683431387">"Omogućuje aplikaciji dohvaćanje, pregledavanje i brisanje obavijesti, uključujući obavijesti drugih aplikacija."</string>
    <string name="permlab_bindNotificationListenerService" msgid="7057764742211656654">"vezanje uz uslugu slušatelja obavijesti"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="985697918576902986">"Nositelju omogućuje vezanje uz sučelje najviše razine usluge slušatelja obavijesti. Ne bi smjelo biti potrebno za uobičajene aplikacije."</string>
    <string name="permlab_bindConditionProviderService" msgid="1180107672332704641">"povezivanje s uslugom davatelja uvjeta"</string>
    <string name="permdesc_bindConditionProviderService" msgid="1680513931165058425">"Vlasniku omogućuje povezivanje sa sučeljem najviše razine usluge davatelja uvjeta. Nije potrebno za normalne aplikacije."</string>
    <string name="permlab_bindDreamService" msgid="4153646965978563462">"vezanje na Dream"</string>
    <string name="permdesc_bindDreamService" msgid="7325825272223347863">"Vlasniku omogućuje povezivanje sa sučeljem najviše razine za Dream. Ne bi trebalo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_invokeCarrierSetup" msgid="3699600833975117478">"pozovi operaterovu aplikaciju za konfiguraciju"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4159549152529111920">"Dopušta nositelju pozivanje operaterove aplikacije za konfiguraciju. Ne bi smjelo biti potrebno za uobičajene aplikacije."</string>
    <string name="permlab_accessNetworkConditions" msgid="8206077447838909516">"praćenje motrenja mrežnih uvjeta"</string>
    <string name="permdesc_accessNetworkConditions" msgid="6899102075825272211">"Omogućuje aplikaciji praćenje motrenja mrežnih uvjeta. Ne bi trebalo biti potrebno za uobičajene aplikacije."</string>
    <string name="permlab_setInputCalibration" msgid="4902620118878467615">"promjena kalibracije uređaja za unos"</string>
    <string name="permdesc_setInputCalibration" msgid="4527511047549456929">"Omogućuje aplikaciji izmjenu parametara kalibracije dodirnog zaslona. Ne bi trebalo biti potrebno za uobičajene aplikacije."</string>
    <string name="permlab_accessDrmCertificates" msgid="7436886640723203615">"pristup DRM certifikatima"</string>
    <string name="permdesc_accessDrmCertificates" msgid="8073288354426159089">"Aplikaciji omogućuje pružanje i korištenje DRM certifikata. Ne bi trebalo biti potrebno za uobičajene aplikacije."</string>
    <string name="permlab_handoverStatus" msgid="1159132046126626731">"Primanje statusa prijenosa Android Beama"</string>
    <string name="permdesc_handoverStatus" msgid="4788144087245714948">"Omogućuje aplikaciji primanje podataka o trenutačnim prijenosima Android Beama"</string>
    <string name="permlab_removeDrmCertificates" msgid="7044888287209892751">"uklanjanje DRM certifikata"</string>
    <string name="permdesc_removeDrmCertificates" msgid="7272999075113400993">"Omogućuje aplikaciji uklanjanje DRM certifikata. Ne bi trebalo biti potrebno za uobičajene aplikacije."</string>
    <string name="policylab_limitPassword" msgid="4497420728857585791">"Postavi pravila zaporke"</string>
    <string name="policydesc_limitPassword" msgid="3252114203919510394">"Upravljajte duljinom zaporki za otključavanje zaslona i dopuštenim znakovima u tim zaporkama."</string>
    <string name="policylab_watchLogin" msgid="914130646942199503">"Nadgledaj pokušaje otključavanja zaslona"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="3215729294215070072">"Nadziri broj netočnih zaporki unesenih pri otključavanju zaslona i zaključaj tabletno računalo ili izbriši sve podatke na njemu ako je uneseno previše netočnih zaporki."</string>
    <string name="policydesc_watchLogin" product="default" msgid="5712323091846761073">"Nadzire broj netočno unesenih zaporki pri otključavanju zaslona i zaključava telefon ili briše sve podatke na telefonu ako je uneseno previše netočnih zaporki."</string>
    <string name="policylab_resetPassword" msgid="2620077191242688955">"Promijeni zaporku za otključavanje zaslona"</string>
    <string name="policydesc_resetPassword" msgid="605963962301904458">"Promijenite zaporku za otključavanje zaslona."</string>
    <string name="policylab_forceLock" msgid="2274085384704248431">"Zaključaj zaslon"</string>
    <string name="policydesc_forceLock" msgid="1141797588403827138">"Upravlja se načinom i vremenom zaključavanja zaslona."</string>
    <string name="policylab_wipeData" msgid="3910545446758639713">"Izbriši sve podatke"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="4306184096067756876">"Vraćanjem u tvorničko stanje izbriši podatke tabletnog računala bez upozorenja."</string>
    <string name="policydesc_wipeData" product="default" msgid="5096895604574188391">"Vraćanjem na tvorničke postavke brišu se podaci s telefona bez upozorenja."</string>
    <string name="policylab_setGlobalProxy" msgid="2784828293747791446">"postavi globalni proxy uređaja"</string>
    <string name="policydesc_setGlobalProxy" msgid="6387497466660154931">"Postavi globalni proxy uređaja za upotrebu dok su pravila omogućena. Samo prvi administrator uređaja postavlja djelotvoran globalni proxy."</string>
    <string name="policylab_expirePassword" msgid="885279151847254056">"Post. istek zap. zaklj. zasl."</string>
    <string name="policydesc_expirePassword" msgid="1729725226314691591">"Upravljajte učestalošću promjena zaporke za zaključavanje zaslona."</string>
    <string name="policylab_encryptedStorage" msgid="8901326199909132915">"Postavi enkripciju za pohranu"</string>
    <string name="policydesc_encryptedStorage" msgid="2637732115325316992">"Zahtijevajte da pohranjeni podaci aplikacije budu šifrirani."</string>
    <string name="policylab_disableCamera" msgid="6395301023152297826">"Onemogući fotoaparate"</string>
    <string name="policydesc_disableCamera" msgid="2306349042834754597">"Spriječite upotrebu svih kamera uređaja."</string>
    <string name="policylab_disableKeyguardFeatures" msgid="266329104542638802">"Onemogući zaštitu tipkovnice"</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="3467082272186534614">"Sprječava se upotreba nekih značajki u zaštitnom zaključavanju tipkovnice."</string>
  <string-array name="phoneTypes">
    <item msgid="8901098336658710359">"Privatni"</item>
    <item msgid="869923650527136615">"Mobilni"</item>
    <item msgid="7897544654242874543">"Službeni"</item>
    <item msgid="1103601433382158155">"Službeni faks"</item>
    <item msgid="1735177144948329370">"Faks kod kuće"</item>
    <item msgid="603878674477207394">"Dojavljivač"</item>
    <item msgid="1650824275177931637">"Ostalo"</item>
    <item msgid="9192514806975898961">"Prilagođeno"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="8073994352956129127">"Privatna"</item>
    <item msgid="7084237356602625604">"Službena"</item>
    <item msgid="1112044410659011023">"Ostalo"</item>
    <item msgid="2374913952870110618">"Prilagođeno"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="6880257626740047286">"Privatna"</item>
    <item msgid="5629153956045109251">"Službena"</item>
    <item msgid="4966604264500343469">"Ostalo"</item>
    <item msgid="4932682847595299369">"Prilagođeno"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="1738585194601476694">"Privatni"</item>
    <item msgid="1359644565647383708">"Službeni"</item>
    <item msgid="7868549401053615677">"Ostalo"</item>
    <item msgid="3145118944639869809">"Prilagođeno"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="7546335612189115615">"Posao"</item>
    <item msgid="4378074129049520373">"Ostalo"</item>
    <item msgid="3455047468583965104">"Prilagođeno"</item>
  </string-array>
  <string-array name="imProtocols">
    <item msgid="8595261363518459565">"AIM"</item>
    <item msgid="7390473628275490700">"Windows Live"</item>
    <item msgid="7882877134931458217">"Yahoo"</item>
    <item msgid="5035376313200585242">"Skype"</item>
    <item msgid="7532363178459444943">"QQ"</item>
    <item msgid="3713441034299660749">"Google Talk"</item>
    <item msgid="2506857312718630823">"ICQ"</item>
    <item msgid="1648797903785279353">"Jabber"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="1644738059053355820">"Prilagođeno"</string>
    <string name="phoneTypeHome" msgid="2570923463033985887">"Privatni"</string>
    <string name="phoneTypeMobile" msgid="6501463557754751037">"Mobilni"</string>
    <string name="phoneTypeWork" msgid="8863939667059911633">"Službeni"</string>
    <string name="phoneTypeFaxWork" msgid="3517792160008890912">"Službeni faks"</string>
    <string name="phoneTypeFaxHome" msgid="2067265972322971467">"Faks kod kuće"</string>
    <string name="phoneTypePager" msgid="7582359955394921732">"Dojavljivač"</string>
    <string name="phoneTypeOther" msgid="1544425847868765990">"Ostalo"</string>
    <string name="phoneTypeCallback" msgid="2712175203065678206">"Povratni poziv"</string>
    <string name="phoneTypeCar" msgid="8738360689616716982">"Automobil"</string>
    <string name="phoneTypeCompanyMain" msgid="540434356461478916">"Primarni broj za tvrtku"</string>
    <string name="phoneTypeIsdn" msgid="8022453193171370337">"ISDN"</string>
    <string name="phoneTypeMain" msgid="6766137010628326916">"Glavni telefon"</string>
    <string name="phoneTypeOtherFax" msgid="8587657145072446565">"Drugi faks"</string>
    <string name="phoneTypeRadio" msgid="4093738079908667513">"Radio"</string>
    <string name="phoneTypeTelex" msgid="3367879952476250512">"Teleks"</string>
    <string name="phoneTypeTtyTdd" msgid="8606514378585000044">"TTY TDD"</string>
    <string name="phoneTypeWorkMobile" msgid="1311426989184065709">"Službeni mobitel"</string>
    <string name="phoneTypeWorkPager" msgid="649938731231157056">"Poslovni dojavljivač"</string>
    <string name="phoneTypeAssistant" msgid="5596772636128562884">"Pomoćnik"</string>
    <string name="phoneTypeMms" msgid="7254492275502768992">"MMS"</string>
    <string name="eventTypeCustom" msgid="7837586198458073404">"Prilagođeno"</string>
    <string name="eventTypeBirthday" msgid="2813379844211390740">"Rođendan"</string>
    <string name="eventTypeAnniversary" msgid="3876779744518284000">"Godišnjica"</string>
    <string name="eventTypeOther" msgid="7388178939010143077">"Drugo"</string>
    <string name="emailTypeCustom" msgid="8525960257804213846">"Prilagođeno"</string>
    <string name="emailTypeHome" msgid="449227236140433919">"Privatna"</string>
    <string name="emailTypeWork" msgid="3548058059601149973">"Službena"</string>
    <string name="emailTypeOther" msgid="2923008695272639549">"Ostalo"</string>
    <string name="emailTypeMobile" msgid="119919005321166205">"Mobilni"</string>
    <string name="postalTypeCustom" msgid="8903206903060479902">"Prilagođeno"</string>
    <string name="postalTypeHome" msgid="8165756977184483097">"Privatna"</string>
    <string name="postalTypeWork" msgid="5268172772387694495">"Službena"</string>
    <string name="postalTypeOther" msgid="2726111966623584341">"Ostalo"</string>
    <string name="imTypeCustom" msgid="2074028755527826046">"Prilagođeno"</string>
    <string name="imTypeHome" msgid="6241181032954263892">"Privatna"</string>
    <string name="imTypeWork" msgid="1371489290242433090">"Službeni"</string>
    <string name="imTypeOther" msgid="5377007495735915478">"Ostalo"</string>
    <string name="imProtocolCustom" msgid="6919453836618749992">"Prilagođeno"</string>
    <string name="imProtocolAim" msgid="7050360612368383417">"AIM"</string>
    <string name="imProtocolMsn" msgid="144556545420769442">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="8271439408469021273">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="9019296744622832951">"Skype"</string>
    <string name="imProtocolQq" msgid="8887484379494111884">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="493902321140277304">"Hangouts"</string>
    <string name="imProtocolIcq" msgid="1574870433606517315">"ICQ"</string>
    <string name="imProtocolJabber" msgid="2279917630875771722">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="8287625655986827971">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="29268870505363872">"Posao"</string>
    <string name="orgTypeOther" msgid="3951781131570124082">"Ostalo"</string>
    <string name="orgTypeCustom" msgid="225523415372088322">"Prilagođeno"</string>
    <string name="relationTypeCustom" msgid="3542403679827297300">"Prilagođeno"</string>
    <string name="relationTypeAssistant" msgid="6274334825195379076">"Pomoćnik"</string>
    <string name="relationTypeBrother" msgid="8757913506784067713">"Brat"</string>
    <string name="relationTypeChild" msgid="1890746277276881626">"Dijete"</string>
    <string name="relationTypeDomesticPartner" msgid="6904807112121122133">"Partner u kućan."</string>
    <string name="relationTypeFather" msgid="5228034687082050725">"Otac"</string>
    <string name="relationTypeFriend" msgid="7313106762483391262">"Prijatelj"</string>
    <string name="relationTypeManager" msgid="6365677861610137895">"Voditelj"</string>
    <string name="relationTypeMother" msgid="4578571352962758304">"Majka"</string>
    <string name="relationTypeParent" msgid="4755635567562925226">"Roditelj"</string>
    <string name="relationTypePartner" msgid="7266490285120262781">"Partner"</string>
    <string name="relationTypeReferredBy" msgid="101573059844135524">"Preporučuje"</string>
    <string name="relationTypeRelative" msgid="1799819930085610271">"Rođak"</string>
    <string name="relationTypeSister" msgid="1735983554479076481">"Sestra"</string>
    <string name="relationTypeSpouse" msgid="394136939428698117">"Bračni partner"</string>
    <string name="sipAddressTypeCustom" msgid="2473580593111590945">"Prilagođeno"</string>
    <string name="sipAddressTypeHome" msgid="6093598181069359295">"Privatna"</string>
    <string name="sipAddressTypeWork" msgid="6920725730797099047">"Službena"</string>
    <string name="sipAddressTypeOther" msgid="4408436162950119849">"Drugo"</string>
    <string name="quick_contacts_not_available" msgid="746098007828579688">"Nema aplikacije za prikazivanje tog kontakta."</string>
    <string name="keyguard_password_enter_pin_code" msgid="3037685796058495017">"Unesite PIN kôd"</string>
    <string name="keyguard_password_enter_puk_code" msgid="4800725266925845333">"Unesite PUK i novi PIN kôd"</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="1341112146710087048">"PUK kôd"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="8027680321614196258">"Novi PIN kôd"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="7858547464982981384"><font size="17">"Dodirnite za tipkanje zaporke"</font></string>
    <string name="keyguard_password_enter_password_code" msgid="1054721668279049780">"Unesite zaporku za otključavanje"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="6391755146112503443">"Unesite PIN za otključavanje"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="2422225591006134936">"Netočan PIN kôd."</string>
    <string name="keyguard_label_text" msgid="861796461028298424">"Za otključavanje pritisnite Izbornik pa 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="696192103195090970">"Broj hitne službe"</string>
    <string name="lockscreen_carrier_default" msgid="8963839242565653192">"Nema usluge."</string>
    <string name="lockscreen_screen_locked" msgid="7288443074806832904">"Zaslon zaključan."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="46154051614126049">"Pritisnite Izbornik za otključavanje ili pozivanje hitnih službi."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="686260028797158364">"Pritisnite Izbornik za otključavanje."</string>
    <string name="lockscreen_pattern_instructions" msgid="7478703254964810302">"Iscrtajte uzorak za otključavanje"</string>
    <string name="lockscreen_emergency_call" msgid="5347633784401285225">"Hitan poziv"</string>
    <string name="lockscreen_return_to_call" msgid="5244259785500040021">"Uzvrati poziv"</string>
    <string name="lockscreen_pattern_correct" msgid="9039008650362261237">"Ispravno!"</string>
    <string name="lockscreen_pattern_wrong" msgid="4317955014948108794">"Pokušajte ponovo"</string>
    <string name="lockscreen_password_wrong" msgid="5737815393253165301">"Pokušajte ponovo"</string>
    <string name="faceunlock_multiple_failures" msgid="754137583022792429">"Premašen je maksimalni broj Otključavanja licem"</string>
    <string name="lockscreen_plugged_in" msgid="8057762828355572315">"Punjenje, <xliff:g id="NUMBER">%d</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_charged" msgid="321635745684060624">"Napunjeno"</string>
    <string name="lockscreen_battery_short" msgid="4477264849386850266">"<xliff:g id="NUMBER">%d</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_low_battery" msgid="1482873981919249740">"Priključite punjač."</string>
    <string name="lockscreen_missing_sim_message_short" msgid="5099439277819215399">"Nema SIM kartice"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="151659196095791474">"U tabletnom uređaju nema SIM kartice."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="2186920585695169078">"U telefonu nema SIM kartice."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="5372787138023272615">"Umetnite SIM karticu."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3526573099019319472">"SIM kartica nedostaje ili nije čitljiva. Umetnite SIM karticu."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="5096149665138916184">"Neupotrebljiva SIM kartica."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="910904643433151371">"Vaša SIM kartica trajno je onemogućena.\n Obratite se svom pružatelju bežičnih usluga da biste dobili drugu SIM karticu."</string>
    <string name="lockscreen_transport_prev_description" msgid="6300840251218161534">"Prethodna pjesma"</string>
    <string name="lockscreen_transport_next_description" msgid="573285210424377338">"Sljedeća pjesma"</string>
    <string name="lockscreen_transport_pause_description" msgid="3980308465056173363">"Pauziraj"</string>
    <string name="lockscreen_transport_play_description" msgid="1901258823643886401">"Reproduciraj"</string>
    <string name="lockscreen_transport_stop_description" msgid="5907083260651210034">"Zaustavi"</string>
    <string name="lockscreen_transport_rew_description" msgid="6944412838651990410">"Unatrag"</string>
    <string name="lockscreen_transport_ffw_description" msgid="42987149870928985">"Brzo unaprijed"</string>
    <string name="emergency_calls_only" msgid="6733978304386365407">"Samo hitni pozivi"</string>
    <string name="lockscreen_network_locked_message" msgid="143389224986028501">"Mreža je zaključana"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="7441797339976230">"SIM kartica je zaključana PUK-om."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="8127916255245181063">"Pogledajte korisnički priručnik ili kontaktirajte korisničku službu."</string>
    <string name="lockscreen_sim_locked_message" msgid="8066660129206001039">"SIM kartica je zaključana."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="595323214052881264">"Otključavanje SIM kartice…"</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6481623830344107222">"Netočno ste iscrtali uzorak za otključavanje <xliff:g id="NUMBER_0">%d</xliff:g> puta. \n\nPokušajte ponovo za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="2725973286239344555">"Netočno ste napisali zaporku <xliff:g id="NUMBER_0">%d</xliff:g> puta. \n\nPokušajte ponovo za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="6216672706545696955">"Netočno ste napisali PIN <xliff:g id="NUMBER_0">%d</xliff:g> puta. \n\nPokušajte ponovo za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="9191611984625460820">"Netočno ste iscrtali uzorak za otključavanje <xliff:g id="NUMBER_0">%d</xliff:g> puta. Nakon još ovoliko neuspješnih pokušaja: <xliff:g id="NUMBER_1">%d</xliff:g> zamolit ćemo vas da otključate tabletno računalo putem prijave na Google.\n\n Pokušajte ponovo za <xliff:g id="NUMBER_2">%d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="2590227559763762751">"Netočno ste iscrtali uzorak za otključavanje <xliff:g id="NUMBER_0">%d</xliff:g> puta. Nakon još ovoliko neuspješnih pokušaja: <xliff:g id="NUMBER_1">%d</xliff:g> morat ćete otključati telefon putem prijave na Google.\n\n Pokušajte ponovo za <xliff:g id="NUMBER_2">%d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="6128106399745755604">"Neispravno ste pokušali otključati tabletno računalo ovoliko puta: <xliff:g id="NUMBER_0">%d</xliff:g>. Ono će se vratiti na tvorničke postavke i svi korisnički podaci bit će izgubljeni nakon još ovoliko neuspjelih pokušaja: <xliff:g id="NUMBER_1">%d</xliff:g>."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="8603565142156826565">"Neispravno ste pokušali otključati telefon ovoliko puta: <xliff:g id="NUMBER_0">%d</xliff:g>. On će se vratiti na tvorničke postavke i svi korisnički podaci bit će izgubljeni nakon još ovoliko neuspjelih pokušaja: <xliff:g id="NUMBER_1">%d</xliff:g>."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="280873516493934365">"Neispravno ste pokušali otključati tabletno računalo ovoliko puta: <xliff:g id="NUMBER">%d</xliff:g>. Sada će biti vraćeno na tvorničke postavke."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="3025504721764922246">"Neispravno ste pokušali otključati telefon ovoliko puta: <xliff:g id="NUMBER">%d</xliff:g>. Sada će biti vraćen na tvorničke postavke."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6251480343394389665">"Pokušajte ponovno za <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="2626999449610695930">"Zaboravili ste uzorak?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="2588521501166032747">"Otključaj račun"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="2751368605287288808">"Previše pokušaja iscrtavanja uzorka"</string>
    <string name="lockscreen_glogin_instructions" msgid="3931816256100707784">"Za otključavanje prijavite se s Google računom."</string>
    <string name="lockscreen_glogin_username_hint" msgid="8846881424106484447">"Korisničko ime (e-pošta)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="5958028383954738528">"Zaporka"</string>
    <string name="lockscreen_glogin_submit_button" msgid="7130893694795786300">"Prijava"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="1364051473347485908">"Nevažeće korisničko ime ili zaporka."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1696924763690379073">"Zaboravili ste korisničko ime ili zaporku?\nPosjetite "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="lockscreen_glogin_checking_password" msgid="7114627351286933867">"Provjeravanje..."</string>
    <string name="lockscreen_unlock_label" msgid="737440483220667054">"Otključaj"</string>
    <string name="lockscreen_sound_on_label" msgid="9068877576513425970">"Zvuk je uključen"</string>
    <string name="lockscreen_sound_off_label" msgid="996822825154319026">"Zvuk isključen"</string>
    <string name="lockscreen_access_pattern_start" msgid="3941045502933142847">"Uzorak se pokrenuo"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="5583479721001639579">"Uzorak je obrisan"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6756031208359292487">"Dodan je mobitel"</string>
    <string name="lockscreen_access_pattern_detected" msgid="4988730895554057058">"Uzorak je dovršen"</string>
    <string name="keyguard_accessibility_widget_changed" msgid="5678624624681400191">"%1$s. Widget %2$d od %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8273277058724924654">"Dodavanje widgeta."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="1281505703307930757">"Prazno"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="2278106022311170299">"Područje za otključavanje prošireno je."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="6366992066936076396">"Područje za otključavanje sažeto je."</string>
    <string name="keyguard_accessibility_widget" msgid="6527131039741808240">"<xliff:g id="WIDGET_INDEX">%1$s</xliff:g> widget."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1226798370913698896">"Birač korisnika"</string>
    <string name="keyguard_accessibility_status" msgid="8008264603935930611">"Status"</string>
    <string name="keyguard_accessibility_camera" msgid="8904231194181114603">"Fotoaparat"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="262209654292161806">"Nadzor medija"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="8736853615588828197">"Pokrenuta je promjena redoslijeda widgeta."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="7170190950870468320">"Završena je promjena redoslijeda widgeta."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="4426204263929224434">"Widget <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> izbrisan je."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="519859720934178024">"Proširivanje područja za otključavanje."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2959928478764697254">"Otključavanje klizanjem."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="1490840706075246612">"Uzorak za otključavanje."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="4817282543351718535">"Otključavanje licem."</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="2469687111784035046">"Otključavanje PIN-om."</string>
    <string name="keyguard_accessibility_password_unlock" msgid="7675777623912155089">"Otključavanje zaporkom."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="7679891324509597904">"Područje uzorka."</string>
    <string name="keyguard_accessibility_slide_area" msgid="6736064494019979544">"Područje klizanja."</string>
    <string name="password_keyboard_label_symbol_key" msgid="992280756256536042">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="8001096175167485649">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="1284820942620288678">"ALT"</string>
    <string name="granularity_label_character" msgid="7336470535385009523">"znak"</string>
    <string name="granularity_label_word" msgid="7075570328374918660">"riječ"</string>
    <string name="granularity_label_link" msgid="5815508880782488267">"veza"</string>
    <string name="granularity_label_line" msgid="5764267235026120888">"redak"</string>
    <string name="hour_ampm" msgid="4584338083529355982">"<xliff:g id="HOUR">%-l</xliff:g> <xliff:g id="AMPM">%P</xliff:g>"</string>
    <string name="hour_cap_ampm" msgid="2083465992940444366">"<xliff:g id="HOUR">%-l</xliff:g> <xliff:g id="AMPM">%p</xliff:g>"</string>
    <string name="factorytest_failed" msgid="5410270329114212041">"Tvorničko testiranje nije uspjelo"</string>
    <string name="factorytest_not_system" msgid="4435201656767276723">"Radnja FACTORY_TEST podržana je samo za pakete instalirane na /sustavu/aplikaciji."</string>
    <string name="factorytest_no_action" msgid="872991874799998561">"Nije pronađen paket koji sadrži radnju FACTORY_TEST."</string>
    <string name="factorytest_reboot" msgid="6320168203050791643">"Ponovno pokreni"</string>
    <string name="js_dialog_title" msgid="1987483977834603872">"Stranica na adresi \"<xliff:g id="TITLE">%s</xliff:g>\" sadrži sljedeće:"</string>
    <string name="js_dialog_title_default" msgid="6961903213729667573">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="2619376555525116593">"Potvrda kretanja"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="3112752010600484130">"Napusti stranicu"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="5614861293026099715">"Ostani na ovoj stranici"</string>
    <string name="js_dialog_before_unload" msgid="3468816357095378590">"<xliff:g id="MESSAGE">%s</xliff:g>\n\nJeste li sigurni da želite napustiti ovu stranicu?"</string>
    <string name="save_password_label" msgid="6860261758665825069">"Potvrdi"</string>
    <string name="double_tap_toast" msgid="4595046515400268881">"Savjet: Dvaput dotaknite za povećavanje i smanjivanje."</string>
    <string name="autofill_this_form" msgid="4616758841157816676">"Aut.pop."</string>
    <string name="setup_autofill" msgid="7103495070180590814">"Post. Auto. pop."</string>
    <string name="autofill_address_name_separator" msgid="6350145154779706772">" "</string>
    <string name="autofill_address_summary_name_format" msgid="3268041054899214945">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="7483307893170324129">", "</string>
    <string name="autofill_address_summary_format" msgid="4874459455786827344">"$1$2$3"</string>
    <string name="autofill_province" msgid="2231806553863422300">"Pokrajina"</string>
    <string name="autofill_postal_code" msgid="4696430407689377108">"Poštanski broj"</string>
    <string name="autofill_state" msgid="6988894195520044613">"Država"</string>
    <string name="autofill_zip_code" msgid="8697544592627322946">"Poštanski broj"</string>
    <string name="autofill_county" msgid="237073771020362891">"Županija"</string>
    <string name="autofill_island" msgid="4020100875984667025">"Otok"</string>
    <string name="autofill_district" msgid="8400735073392267672">"Okrug"</string>
    <string name="autofill_department" msgid="5343279462564453309">"Odjel"</string>
    <string name="autofill_prefecture" msgid="2028499485065800419">"Prefektura"</string>
    <string name="autofill_parish" msgid="8202206105468820057">"Župa"</string>
    <string name="autofill_area" msgid="3547409050889952423">"Područje"</string>
    <string name="autofill_emirate" msgid="2893880978835698818">"Emirat"</string>
    <string name="permlab_readHistoryBookmarks" msgid="3775265775405106983">"čitanje web-oznaka i povijesti"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="8462378226600439658">"Aplikaciji omogućuje čitanje povijesti svih URL-ova koje je Preglednik posjetio te svih oznaka u Pregledniku. Napomena: tu dozvolu ne mogu primijeniti preglednici treće strane niti druge aplikacije s mogućnostima pregledavanja weba."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="3714785165273314490">"pisanje web-oznaka i povijesti"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="6825527469145760922">"Aplikaciji omogućuje izmjenu povijesti i oznaka Preglednika pohranjenih na tabletnom računalu. To aplikaciji može omogućiti brisanje ili izmjenu podataka Preglednika. Napomena: tu dozvolu ne mogu primijeniti preglednici treće strane ili druge aplikacije s mogućnostima pregledavanja weba."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="8497389531014185509">"Aplikaciji omogućuje izmjenu povijesti i oznaka Preglednika pohranjenih na telefonu. To aplikaciji može omogućiti brisanje ili izmjenu podataka Preglednika. Napomena: tu dozvolu ne mogu primijeniti preglednici treće strane ili druge aplikacije s mogućnostima pregledavanja weba."</string>
    <string name="permlab_setAlarm" msgid="1379294556362091814">"postavljanje alarma"</string>
    <string name="permdesc_setAlarm" msgid="316392039157473848">"Omogućuje aplikaciji postavljanje alarma na instaliranoj aplikaciji budilici. Neke aplikacije budilice možda neće primijeniti tu značajku."</string>
    <string name="permlab_writeVoicemail" msgid="7309899891683938100">"pisanje govorne pošte"</string>
    <string name="permdesc_writeVoicemail" msgid="6592572839715924830">"Omogućuje aplikaciji izmjenjivanje i uklanjanje poruka iz dolazne govorne pošte."</string>
    <string name="permlab_addVoicemail" msgid="5525660026090959044">"dodaj govornu poštu"</string>
    <string name="permdesc_addVoicemail" msgid="6604508651428252437">"Omogućuje aplikaciji da doda poruke u vašu govornu poštu."</string>
    <string name="permlab_readVoicemail" msgid="8415201752589140137">"čitanje govorne pošte"</string>
    <string name="permdesc_readVoicemail" msgid="8926534735321616550">"Omogućuje aplikaciji čitanje vaše govorne pošte."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="5962224158955273932">"izmjena dozvola za geolociranje u pregledniku"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="1083743234522638747">"Omogućuje aplikaciji promjenu geolokacijskih dozvola preglednika. Zlonamjerne aplikacije mogu to upotrijebiti da bi dopustile slanje podataka o lokaciji nasumičnim web-lokacijama."</string>
    <string name="permlab_packageVerificationAgent" msgid="5568139100645829117">"provjeri pakete"</string>
    <string name="permdesc_packageVerificationAgent" msgid="8437590190990843381">"Aplikaciji omogućuje da provjeri je li paket moguće instalirati."</string>
    <string name="permlab_bindPackageVerifier" msgid="4187786793360326654">"vezano uz paketnu provjeru"</string>
    <string name="permdesc_bindPackageVerifier" msgid="3180741773233862126">"Nositelju omogućuje da traži paketnu provjeru. Ne bi smjelo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_serialPort" msgid="546083327654631076">"pristup serijskim priključcima"</string>
    <string name="permdesc_serialPort" msgid="2991639985224598193">"Rukovatelju omogućuje pristup serijskim priključcima pomoću značajke SerialManager API."</string>
    <string name="permlab_accessContentProvidersExternally" msgid="5077774297943409285">"pristup pružateljima sadržaja izvana"</string>
    <string name="permdesc_accessContentProvidersExternally" msgid="4544346486697853685">"Omogućuje vlasniku pristup pružateljima sadržaja iz programske ovojnice. Ne bi trebalo biti potrebno za normalne aplikacije."</string>
    <string name="permlab_updateLock" msgid="3527558366616680889">"odvratiti automatska ažuriranja uređaja"</string>
    <string name="permdesc_updateLock" msgid="1655625832166778492">"Omogućuje vlasniku davanje informacija sustavu o pogodnom trenutku za nadogradnju uređaja ponovnim pokretanjem bez interakcije."</string>
    <string name="save_password_message" msgid="767344687139195790">"Želite li da preglednik zapamti ovu zaporku?"</string>
    <string name="save_password_notnow" msgid="6389675316706699758">"Ne sada"</string>
    <string name="save_password_remember" msgid="6491879678996749466">"Zapamti"</string>
    <string name="save_password_never" msgid="8274330296785855105">"Nikad"</string>
    <string name="open_permission_deny" msgid="7374036708316629800">"Nemate dozvolu za otvaranje te stranice."</string>
    <string name="text_copied" msgid="4985729524670131385">"Tekst kopiran u međuspremnik."</string>
    <string name="more_item_label" msgid="4650918923083320495">"Više"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Izbornik+"</string>
    <string name="menu_space_shortcut_label" msgid="2410328639272162537">"razmak"</string>
    <string name="menu_enter_shortcut_label" msgid="2743362785111309668">"enter"</string>
    <string name="menu_delete_shortcut_label" msgid="3658178007202748164">"izbriši"</string>
    <string name="search_go" msgid="8298016669822141719">"Pretraži"</string>
    <string name="searchview_description_search" msgid="6749826639098512120">"Pretraživanje"</string>
    <string name="searchview_description_query" msgid="5911778593125355124">"Upit za pretraživanje"</string>
    <string name="searchview_description_clear" msgid="1330281990951833033">"Izbriši upit"</string>
    <string name="searchview_description_submit" msgid="2688450133297983542">"Pošalji upit"</string>
    <string name="searchview_description_voice" msgid="2453203695674994440">"Glasovno pretraživanje"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="7460694070309730149">"Omogućiti Istraživanje dodirom?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="8655887539089910577">"Usluga <xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> želi omogućiti značajku Istraživanje dodirom. Kad je značajka Istraživanje dodirom uključena, možete čuti ili vidjeti opise onoga što je pod vašim prstom ili izvršiti pokrete za interakciju s tabletnim računalom."</string>
    <string name="enable_explore_by_touch_warning_message" product="default" msgid="2708199672852373195">"Usluga <xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> želi omogućiti značajku Istraživanje dodirom. Kad je značajka Istraživanje dodirom uključena, možete čuti ili vidjeti opise onoga što je pod vašim prstom ili izvršiti pokrete za interakciju s telefonom."</string>
    <string name="oneMonthDurationPast" msgid="7396384508953779925">"Prije 1 mjesec"</string>
    <string name="beforeOneMonthDurationPast" msgid="909134546836499826">"Prije 1 mjesec"</string>
    <plurals name="num_seconds_ago" formatted="false" msgid="5758689745711719722">
      <item quantity="one">prije <xliff:g id="COUNT">%d</xliff:g> sekunde</item>
      <item quantity="few">prije <xliff:g id="COUNT">%d</xliff:g> sekunde</item>
      <item quantity="other">prije <xliff:g id="COUNT">%d</xliff:g> sekundi</item>
    </plurals>
    <plurals name="num_minutes_ago" formatted="false" msgid="1316158837806796048">
      <item quantity="one">prije <xliff:g id="COUNT">%d</xliff:g> minute</item>
      <item quantity="few">prije <xliff:g id="COUNT">%d</xliff:g> minute</item>
      <item quantity="other">prije <xliff:g id="COUNT">%d</xliff:g> minuta</item>
    </plurals>
    <plurals name="num_hours_ago" formatted="false" msgid="536049915552841680">
      <item quantity="one">prije <xliff:g id="COUNT">%d</xliff:g> sat</item>
      <item quantity="few">prije <xliff:g id="COUNT">%d</xliff:g> sata</item>
      <item quantity="other">prije <xliff:g id="COUNT">%d</xliff:g> sati</item>
    </plurals>
    <plurals name="last_num_days" formatted="false" msgid="5104533550723932025">
      <item quantity="one">Posljednjih <xliff:g id="COUNT_1">%d</xliff:g> dan</item>
      <item quantity="few">Posljednja <xliff:g id="COUNT_1">%d</xliff:g> dana</item>
      <item quantity="other">Posljednjih <xliff:g id="COUNT_1">%d</xliff:g> dana</item>
    </plurals>
    <string name="last_month" msgid="3959346739979055432">"Prošli mjesec"</string>
    <string name="older" msgid="5211975022815554840">"Starije"</string>
    <plurals name="num_days_ago" formatted="false" msgid="7259653235010088281">
      <item quantity="one">prije <xliff:g id="COUNT">%d</xliff:g> dan</item>
      <item quantity="few">prije <xliff:g id="COUNT">%d</xliff:g> dana</item>
      <item quantity="other">prije <xliff:g id="COUNT">%d</xliff:g> dana</item>
    </plurals>
    <plurals name="in_num_seconds" formatted="false" msgid="916057335323583627">
      <item quantity="one">za <xliff:g id="COUNT">%d</xliff:g> sekundu</item>
      <item quantity="few">za <xliff:g id="COUNT">%d</xliff:g> sekunde</item>
      <item quantity="other">za <xliff:g id="COUNT">%d</xliff:g> sekundi</item>
    </plurals>
    <plurals name="in_num_minutes" formatted="false" msgid="958738197454489454">
      <item quantity="one">za <xliff:g id="COUNT">%d</xliff:g> minutu</item>
      <item quantity="few">za <xliff:g id="COUNT">%d</xliff:g> minute</item>
      <item quantity="other">za <xliff:g id="COUNT">%d</xliff:g> minuta</item>
    </plurals>
    <plurals name="in_num_hours" formatted="false" msgid="3795322677968446157">
      <item quantity="one">za <xliff:g id="COUNT">%d</xliff:g> sat</item>
      <item quantity="few">za <xliff:g id="COUNT">%d</xliff:g> sata</item>
      <item quantity="other">za <xliff:g id="COUNT">%d</xliff:g> sati</item>
    </plurals>
    <plurals name="in_num_days" formatted="false" msgid="1488706566722014584">
      <item quantity="one">za <xliff:g id="COUNT">%d</xliff:g> dan</item>
      <item quantity="few">za <xliff:g id="COUNT">%d</xliff:g> dana</item>
      <item quantity="other">za <xliff:g id="COUNT">%d</xliff:g> dana</item>
    </plurals>
    <plurals name="abbrev_num_seconds_ago" formatted="false" msgid="6686259755264474381">
      <item quantity="one">prije <xliff:g id="COUNT">%d</xliff:g> s</item>
      <item quantity="few">prije <xliff:g id="COUNT">%d</xliff:g> s</item>
      <item quantity="other">prije <xliff:g id="COUNT">%d</xliff:g> s</item>
    </plurals>
    <plurals name="abbrev_num_minutes_ago" formatted="false" msgid="534218309835972121">
      <item quantity="one">prije <xliff:g id="COUNT">%d</xliff:g> min</item>
      <item quantity="few">prije <xliff:g id="COUNT">%d</xliff:g> min</item>
      <item quantity="other">prije <xliff:g id="COUNT">%d</xliff:g> min</item>
    </plurals>
    <plurals name="abbrev_num_hours_ago" formatted="false" msgid="5723991167628170403">
      <item quantity="one">prije <xliff:g id="COUNT">%d</xliff:g> sat</item>
      <item quantity="few">prije <xliff:g id="COUNT">%d</xliff:g> sata</item>
      <item quantity="other">prije <xliff:g id="COUNT">%d</xliff:g> sati</item>
    </plurals>
    <plurals name="abbrev_num_days_ago" formatted="false" msgid="2874605076838326011">
      <item quantity="one">prije <xliff:g id="COUNT">%d</xliff:g> dan</item>
      <item quantity="few">prije <xliff:g id="COUNT">%d</xliff:g> dana</item>
      <item quantity="other">prije <xliff:g id="COUNT">%d</xliff:g> dana</item>
    </plurals>
    <plurals name="abbrev_in_num_seconds" formatted="false" msgid="2301527120375906345">
      <item quantity="one">za <xliff:g id="COUNT">%d</xliff:g> s</item>
      <item quantity="few">za <xliff:g id="COUNT">%d</xliff:g> s</item>
      <item quantity="other">za <xliff:g id="COUNT">%d</xliff:g> s</item>
    </plurals>
    <plurals name="abbrev_in_num_minutes" formatted="false" msgid="7389851346130784777">
      <item quantity="one">za <xliff:g id="COUNT">%d</xliff:g> min</item>
      <item quantity="few">za <xliff:g id="COUNT">%d</xliff:g> min</item>
      <item quantity="other">za <xliff:g id="COUNT">%d</xliff:g> min</item>
    </plurals>
    <plurals name="abbrev_in_num_hours" formatted="false" msgid="5331698142388677272">
      <item quantity="one">za <xliff:g id="COUNT">%d</xliff:g> sat</item>
      <item quantity="few">za <xliff:g id="COUNT">%d</xliff:g> sata</item>
      <item quantity="other">za <xliff:g id="COUNT">%d</xliff:g> sati</item>
    </plurals>
    <plurals name="abbrev_in_num_days" formatted="false" msgid="1571346728159142300">
      <item quantity="one">za <xliff:g id="COUNT">%d</xliff:g> dan</item>
      <item quantity="few">za <xliff:g id="COUNT">%d</xliff:g> dana</item>
      <item quantity="other">za <xliff:g id="COUNT">%d</xliff:g> dana</item>
    </plurals>
    <string name="preposition_for_date" msgid="9093949757757445117">"dana <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="5506831244263083793">"u <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="5040395640711867177">"<xliff:g id="YEAR">%s</xliff:g>."</string>
    <string name="day" msgid="8144195776058119424">"dan"</string>
    <string name="days" msgid="4774547661021344602">"dana"</string>
    <string name="hour" msgid="2126771916426189481">"h"</string>
    <string name="hours" msgid="894424005266852993">"h"</string>
    <string name="minute" msgid="9148878657703769868">"min"</string>
    <string name="minutes" msgid="5646001005827034509">"min"</string>
    <string name="second" msgid="3184235808021478">"s"</string>
    <string name="seconds" msgid="3161515347216589235">"s"</string>
    <string name="week" msgid="5617961537173061583">"tjedan"</string>
    <string name="weeks" msgid="6509623834583944518">"tjedna"</string>
    <string name="year" msgid="4001118221013892076">"godina"</string>
    <string name="years" msgid="6881577717993213522">"godina"</string>
    <plurals name="duration_seconds" formatted="false" msgid="4527986939729687805">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> sekunda</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> sekunde</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekundi</item>
    </plurals>
    <plurals name="duration_minutes" formatted="false" msgid="643786953939956125">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> minuta</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> minute</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minuta</item>
    </plurals>
    <plurals name="duration_hours" formatted="false" msgid="6826233369186668274">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> sat</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> sata</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sati</item>
    </plurals>
    <string name="VideoView_error_title" msgid="3534509135438353077">"Problem s videozapisom"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3186670335938670444">"Ovaj videozapis nije valjan za streaming na ovaj uređaj."</string>
    <string name="VideoView_error_text_unknown" msgid="3450439155187810085">"Ovaj videozapis nije moguće reproducirati."</string>
    <string name="VideoView_error_button" msgid="2822238215100679592">"U redu"</string>
    <string name="relative_time" msgid="1818557177829411417">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="7245353528818587908">"podne"</string>
    <string name="Noon" msgid="3342127745230013127">"Podne"</string>
    <string name="midnight" msgid="7166259508850457595">"ponoć"</string>
    <string name="Midnight" msgid="5630806906897892201">"Ponoć"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="4431555943828711473">"<xliff:g id="MINUTES">%1$02d</xliff:g>:<xliff:g id="SECONDS">%2$02d</xliff:g>"</string>
    <string name="elapsed_time_short_format_h_mm_ss" msgid="1846071997616654124">"<xliff:g id="HOURS">%1$d</xliff:g>:<xliff:g id="MINUTES">%2$02d</xliff:g>:<xliff:g id="SECONDS">%3$02d</xliff:g>"</string>
    <string name="selectAll" msgid="6876518925844129331">"Odaberi sve"</string>
    <string name="cut" msgid="3092569408438626261">"Izreži"</string>
    <string name="copy" msgid="2681946229533511987">"Kopiraj"</string>
    <string name="paste" msgid="5629880836805036433">"Zalijepi"</string>
    <string name="replace" msgid="5781686059063148930">"Zamijeni…"</string>
    <string name="delete" msgid="6098684844021697789">"Izbriši"</string>
    <string name="copyUrl" msgid="2538211579596067402">"Kopiraj URL"</string>
    <string name="selectTextMode" msgid="1018691815143165326">"Odabir teksta"</string>
    <string name="textSelectionCABTitle" msgid="5236850394370820357">"Odabir teksta"</string>
    <string name="addToDictionary" msgid="4352161534510057874">"Dodaj u rječnik"</string>
    <string name="deleteText" msgid="6979668428458199034">"Izbriši"</string>
    <string name="inputMethod" msgid="1653630062304567879">"Način unosa"</string>
    <string name="editTextMenuTitle" msgid="4909135564941815494">"Radnje s tekstom"</string>
    <string name="low_internal_storage_view_title" msgid="5576272496365684834">"Ponestaje prostora za pohranu"</string>
    <string name="low_internal_storage_view_text" msgid="6640505817617414371">"Neke sistemske funkcije možda neće raditi"</string>
    <string name="low_internal_storage_view_text_no_boot" msgid="6935190099204693424">"Nema dovoljno pohrane za sustav. Oslobodite 250 MB prostora i pokrenite uređaj ponovo."</string>
    <string name="app_running_notification_title" msgid="8718335121060787914">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> pokrenuta je"</string>
    <string name="app_running_notification_text" msgid="4653586947747330058">"Dodirnite za više informacija ili da biste zaustavili aplikaciju."</string>
    <string name="ok" msgid="5970060430562524910">"U redu"</string>
    <string name="cancel" msgid="6442560571259935130">"Odustani"</string>
    <string name="yes" msgid="5362982303337969312">"U redu"</string>
    <string name="no" msgid="5141531044935541497">"Odustani"</string>
    <string name="dialog_alert_title" msgid="2049658708609043103">"Pažnja"</string>
    <string name="loading" msgid="7933681260296021180">"Učitavanje…"</string>
    <string name="capital_on" msgid="1544682755514494298">"Uklj."</string>
    <string name="capital_off" msgid="6815870386972805832">"Isklj."</string>
    <string name="whichApplication" msgid="4533185947064773386">"Radnju dovrši pomoću stavke"</string>
    <string name="whichApplicationNamed" msgid="8260158865936942783">"Dovršavanje radnje pomoću aplikacije %1$s"</string>
    <string name="whichViewApplication" msgid="3272778576700572102">"Otvaranje pomoću aplikacije"</string>
    <string name="whichViewApplicationNamed" msgid="2286418824011249620">"Otvaranje pomoću aplikacije %1$s"</string>
    <string name="whichEditApplication" msgid="144727838241402655">"Uređivanje pomoću aplikacije"</string>
    <string name="whichEditApplicationNamed" msgid="1775815530156447790">"Uređivanje pomoću aplikacije %1$s"</string>
    <string name="whichSendApplication" msgid="6902512414057341668">"Dijeljenje pomoću aplikacije"</string>
    <string name="whichSendApplicationNamed" msgid="2799370240005424391">"Dijeljenje pomoću aplikacije %1$s"</string>
    <string name="whichHomeApplication" msgid="4307587691506919691">"Odaberite početnu aplikaciju"</string>
    <string name="whichHomeApplicationNamed" msgid="4493438593214760979">"Upotrijebite %1$s kao početnu aplikaciju"</string>
    <string name="alwaysUse" msgid="4583018368000610438">"Koristi se kao zadana postavka za ovu lokaciju."</string>
    <string name="use_a_different_app" msgid="8134926230585710243">"Upotrijebite neku drugu aplikaciju"</string>
    <string name="clearDefaultHintMsg" msgid="3252584689512077257">"Izbrisati zadano u Postavkama sustava &gt; Aplikacije &gt; Preuzimanja."</string>
    <string name="chooseActivity" msgid="7486876147751803333">"Odaberi radnju"</string>
    <string name="chooseUsbActivity" msgid="6894748416073583509">"Odabir aplikacije za USB uređaj"</string>
    <string name="noApplications" msgid="2991814273936504689">"Tu radnju ne može izvesti nijedna aplikacija."</string>
    <string name="aerr_title" msgid="1905800560317137752"></string>
    <string name="aerr_application" msgid="932628488013092776">"Nažalost, aplikacija <xliff:g id="APPLICATION">%1$s</xliff:g> prekinula je s radom."</string>
    <string name="aerr_process" msgid="4507058997035697579">"Nažalost, zaustavljen je proces <xliff:g id="PROCESS">%1$s</xliff:g>."</string>
    <string name="anr_title" msgid="4351948481459135709"></string>
    <string name="anr_activity_application" msgid="1904477189057199066">"Aplikacija <xliff:g id="APPLICATION">%2$s</xliff:g> ne reagira.\n\nŽelite li je zatvoriti?"</string>
    <string name="anr_activity_process" msgid="5776209883299089767">"Aktivnost <xliff:g id="ACTIVITY">%1$s</xliff:g> ne reagira.\n\nŽelite li je zatvoriti?"</string>
    <string name="anr_application_process" msgid="8941757607340481057">"Aplikacija <xliff:g id="APPLICATION">%1$s</xliff:g> ne reagira. Želite li je zatvoriti?"</string>
    <string name="anr_process" msgid="6513209874880517125">"Postupak <xliff:g id="PROCESS">%1$s</xliff:g> ne reagira.\n\nŽelite li ga zatvoriti?"</string>
    <string name="force_close" msgid="8346072094521265605">"U redu"</string>
    <string name="report" msgid="4060218260984795706">"Izvješće"</string>
    <string name="wait" msgid="7147118217226317732">"Pričekaj"</string>
    <string name="webpage_unresponsive" msgid="3272758351138122503">"Stranica ne reagira.\n\nŽelite li ju zatvoriti?"</string>
    <string name="launch_warning_title" msgid="1547997780506713581">"Aplikacija preusmjerena"</string>
    <string name="launch_warning_replace" msgid="6202498949970281412">"<xliff:g id="APP_NAME">%1$s</xliff:g> se izvodi sada."</string>
    <string name="launch_warning_original" msgid="188102023021668683">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> pokrenuta je prva."</string>
    <string name="screen_compat_mode_scale" msgid="3202955667675944499">"Mjerilo"</string>
    <string name="screen_compat_mode_show" msgid="4013878876486655892">"Uvijek prikaži"</string>
    <string name="screen_compat_mode_hint" msgid="1064524084543304459">"Omogućiti to ponovo u Postavkama sustava &gt; Aplikacije &gt; Preuzimanja."</string>
    <string name="smv_application" msgid="3307209192155442829">"Aplikacija <xliff:g id="APPLICATION">%1$s</xliff:g> (proces <xliff:g id="PROCESS">%2$s</xliff:g>) prekršila je vlastito pravilo StrictMode."</string>
    <string name="smv_process" msgid="5120397012047462446">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> prekršio je svoje vlastito pravilo StrictMode."</string>
    <string name="android_upgrading_title" msgid="1584192285441405746">"Android se nadograđuje…"</string>
    <string name="android_start_title" msgid="8418054686415318207">"Pokretanje Androida..."</string>
    <string name="android_upgrading_fstrim" msgid="8036718871534640010">"Optimiziranje pohrane."</string>
    <string name="android_upgrading_apk" msgid="7904042682111526169">"Optimiziranje aplikacije <xliff:g id="NUMBER_0">%1$d</xliff:g> od <xliff:g id="NUMBER_1">%2$d</xliff:g>."</string>
    <string name="android_upgrading_starting_apps" msgid="451464516346926713">"Pokretanje aplikacija."</string>
    <string name="android_upgrading_complete" msgid="1405954754112999229">"Završetak inicijalizacije."</string>
    <string name="heavy_weight_notification" msgid="9087063985776626166">"Izvodi se <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="heavy_weight_notification_detail" msgid="1721681741617898865">"Dodirnite da biste se prebacili na aplikaciju"</string>
    <string name="heavy_weight_switcher_title" msgid="7153167085403298169">"Izmijeniti aplikacije?"</string>
    <string name="heavy_weight_switcher_text" msgid="7022631924534406403">"Već se izvodi neka druga aplikacija koja se mora zaustaviti prije pokretanja nove."</string>
    <string name="old_app_action" msgid="493129172238566282">"Natrag na <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="old_app_description" msgid="2082094275580358049">"Ne pokreći novu aplikaciju."</string>
    <string name="new_app_action" msgid="5472756926945440706">"Pokreni <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="1932143598371537340">"Zaustavi staru aplikaciju bez spremanja."</string>
    <string name="sendText" msgid="5209874571959469142">"Izaberite radnju za tekst"</string>
    <string name="volume_ringtone" msgid="6885421406845734650">"Glasnoća zvona"</string>
    <string name="volume_music" msgid="5421651157138628171">"Glasnoća medija"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="9165984379394601533">"Reprodukcija kroz Bluetooth"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="8310739960973156272">"Postavljena bešumna melodija zvona"</string>
    <string name="volume_call" msgid="3941680041282788711">"Glasnoća poziva"</string>
    <string name="volume_bluetooth_call" msgid="2002891926351151534">"Glasnoća značajke Bluetooth tijekom poziva"</string>
    <string name="volume_alarm" msgid="1985191616042689100">"Glasnoća alarma"</string>
    <string name="volume_notification" msgid="2422265656744276715">"Glasnoća obavijesti"</string>
    <string name="volume_unknown" msgid="1400219669770445902">"Glasnoća"</string>
    <string name="volume_icon_description_bluetooth" msgid="6538894177255964340">"Glasnoća Bluetootha"</string>
    <string name="volume_icon_description_ringer" msgid="3326003847006162496">"Glasnoća melodije zvona"</string>
    <string name="volume_icon_description_incall" msgid="8890073218154543397">"Glasnoća poziva"</string>
    <string name="volume_icon_description_media" msgid="4217311719665194215">"Glasnoća medija"</string>
    <string name="volume_icon_description_notification" msgid="7044986546477282274">"Glasnoća obavijesti"</string>
    <string name="ringtone_default" msgid="3789758980357696936">"Zadana melodija zvona"</string>
    <string name="ringtone_default_with_actual" msgid="8129563480895990372">"Zadana melodija zvona (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="7937634392408977062">"Nijedna"</string>
    <string name="ringtone_picker_title" msgid="3515143939175119094">"Melodije zvona"</string>
    <string name="ringtone_unknown" msgid="5477919988701784788">"Nepoznata melodija zvona"</string>
    <plurals name="wifi_available" formatted="false" msgid="7900333017752027322">
      <item quantity="one">Dostupne su Wi-Fi mreže</item>
      <item quantity="few">Dostupne su Wi-Fi mreže</item>
      <item quantity="other">Dostupne su Wi-Fi mreže</item>
    </plurals>
    <plurals name="wifi_available_detailed" formatted="false" msgid="1140699367193975606">
      <item quantity="one">Dostupne su otvorene Wi-Fi mreže</item>
      <item quantity="few">Dostupne su otvorene Wi-Fi mreže</item>
      <item quantity="other">Dostupne su otvorene Wi-Fi mreže</item>
    </plurals>
    <string name="wifi_available_sign_in" msgid="4029489716605255386">"Prijavite se na Wi-Fi mrežu"</string>
    <string name="network_available_sign_in" msgid="8495155593358054676">"Prijavite se na mrežu"</string>
    <!-- no translation found for network_available_sign_in_detailed (8000081941447976118) -->
    <skip />
    <string name="wifi_watchdog_network_disabled" msgid="7904214231651546347">"Ne može se spojiti na Wi-Fi"</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="5548780776418332675">" ima lošu internetsku vezu."</string>
    <string name="wifi_p2p_dialog_title" msgid="97611782659324517">"Izravni Wi-Fi"</string>
    <string name="wifi_p2p_turnon_message" msgid="2909250942299627244">"Pokreni izravan rad s Wi-Fi mrežom. To će isključiti rad s Wi-Fi klijentom/žarišnom točkom."</string>
    <string name="wifi_p2p_failed_message" msgid="3763669677935623084">"Pokretanje izravne Wi-Fi veze nije moguće."</string>
    <string name="wifi_p2p_enabled_notification_title" msgid="2068321881673734886">"Wi-Fi Direct uključen"</string>
    <string name="wifi_p2p_enabled_notification_message" msgid="1638949953993894335">"Dodirnite za postavke"</string>
    <string name="accept" msgid="1645267259272829559">"Prihvaćam"</string>
    <string name="decline" msgid="2112225451706137894">"Odbaci"</string>
    <string name="wifi_p2p_invitation_sent_title" msgid="1318975185112070734">"Pozivnica je poslana"</string>
    <string name="wifi_p2p_invitation_to_connect_title" msgid="4958803948658533637">"Pozivnica za povezivanje"</string>
    <string name="wifi_p2p_from_message" msgid="570389174731951769">"Šalje:"</string>
    <string name="wifi_p2p_to_message" msgid="248968974522044099">"Prima:"</string>
    <string name="wifi_p2p_enter_pin_message" msgid="5920929550367828970">"Upišite potreban PIN:"</string>
    <string name="wifi_p2p_show_pin_message" msgid="8530563323880921094">"PIN:"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tablet" msgid="8012981257742232475">"Tablet će se privremeno isključiti s Wi-Fija dok je povezan s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="default" msgid="7363907213787469151">"Telefon će se privremeno isključiti s Wi-Fija dok je povezan s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="select_character" msgid="3365550120617701745">"Umetni znak"</string>
    <string name="sms_control_title" msgid="7296612781128917719">"Slanje SMS poruka"</string>
    <string name="sms_control_message" msgid="3867899169651496433">"Aplikacija &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; šalje veliki broj SMS poruka. Želite li dopustiti ovoj aplikaciji da nastavi slati poruke?"</string>
    <string name="sms_control_yes" msgid="3663725993855816807">"Dopusti"</string>
    <string name="sms_control_no" msgid="625438561395534982">"Odbij"</string>
    <string name="sms_short_code_confirm_message" msgid="1645436466285310855">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; želi poslati poruku na &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="5873295990846059400">"To "<b>"će se možda naplatiti"</b>" putem vašeg mobilnog računa."</string>
    <string name="sms_premium_short_code_details" msgid="7869234868023975"><b>"To se naplaćuje putem vašeg mobilnog računa."</b></string>
    <string name="sms_short_code_confirm_allow" msgid="4458878637111023413">"Pošalji"</string>
    <string name="sms_short_code_confirm_deny" msgid="2927389840209170706">"Odustani"</string>
    <string name="sms_short_code_remember_choice" msgid="5289538592272218136">"Zapamti odabir"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="4960944133052287484">"Kasnije to možete promijeniti u odjeljku Postavke &gt; Aplikacije"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="3241181154869493368">"Dopusti uvijek"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="446992765774269673">"Ne dopuštaj nikada"</string>
    <string name="sim_removed_title" msgid="6227712319223226185">"SIM kartica uklonjena"</string>
    <string name="sim_removed_message" msgid="5450336489923274918">"Mobilna mreža neće biti dostupna dok ponovo ne pokrenete uređaj s važećom SIM karticom."</string>
    <string name="sim_done_button" msgid="827949989369963775">"Gotovo"</string>
    <string name="sim_added_title" msgid="3719670512889674693">"SIM kartica dodana"</string>
    <string name="sim_added_message" msgid="7797975656153714319">"Za pristup mobilnoj mreži ponovo pokrenite uređaj."</string>
    <string name="sim_restart_button" msgid="4722407842815232347">"Ponovno pokreni"</string>
    <string name="time_picker_dialog_title" msgid="8349362623068819295">"Postavljanje vremena"</string>
    <string name="date_picker_dialog_title" msgid="5879450659453782278">"Postavi datum"</string>
    <string name="date_time_set" msgid="5777075614321087758">"Postavi"</string>
    <string name="date_time_done" msgid="2507683751759308828">"Gotovo"</string>
    <string name="perms_new_perm_prefix" msgid="8257740710754301407"><font size="12" fgcolor="#ff33b5e5">"NOVO: "</font></string>
    <string name="perms_description_app" msgid="5139836143293299417">"Omogućuje aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="no_permissions" msgid="7283357728219338112">"Nije potrebno dopuštenje"</string>
    <string name="perm_costs_money" msgid="4902470324142151116">"možda ćete morati platiti"</string>
    <string name="usb_storage_activity_title" msgid="4465055157209648641">"USB masovna pohrana"</string>
    <string name="usb_storage_title" msgid="5901459041398751495">"USB povezan"</string>
    <string name="usb_storage_message" product="nosdcard" msgid="3308538094316477839">"Povezali ste se s računalom putem USB-a. Dodirnite gumb u nastavku ako želite kopirati datoteke između računala i USB pohrane uređaja Android."</string>
    <string name="usb_storage_message" product="default" msgid="805351000446037811">"Povezali ste se s računalom putem USB-a. Dodirnite donji gumb ako želite kopirati datoteke između računala i SD kartice svog uređaja Android."</string>
    <string name="usb_storage_button_mount" msgid="1052259930369508235">"Uključi USB pohranjivanje"</string>
    <string name="usb_storage_error_message" product="nosdcard" msgid="3017045217365540658">"Došlo je do problema s upotrebom USB pohrane za USB masovnu pohranu."</string>
    <string name="usb_storage_error_message" product="default" msgid="2876018512716970313">"Došlo je do problema s upotrebom SD kartice za USB masovnu pohranu."</string>
    <string name="usb_storage_notification_title" msgid="8175892554757216525">"USB povezan"</string>
    <string name="usb_storage_notification_message" msgid="939822783828183763">"Dodirnite za kopiranje datoteka na računalo ili s računala."</string>
    <string name="usb_storage_stop_notification_title" msgid="2336058396663516017">"Isključi USB pohranjivanje"</string>
    <string name="usb_storage_stop_notification_message" msgid="1656852098555623822">"Dodirnite za isključivanje USB pohrane."</string>
    <string name="usb_storage_stop_title" msgid="660129851708775853">"USB pohrana se koristi"</string>
    <string name="usb_storage_stop_message" product="nosdcard" msgid="4264025280777219521">"Prije isključivanja USB pohrane uklonite (\"izbacite\") USB pohranu svojeg Android uređaja iz računala."</string>
    <string name="usb_storage_stop_message" product="default" msgid="8043969782460613114">"Prije isključivanja USB pohrane uklonite (\"izbacite\") SD karticu uređaja Android iz računala."</string>
    <string name="usb_storage_stop_button_mount" msgid="7060218034900696029">"Isključi USB pohranjivanje"</string>
    <string name="usb_storage_stop_error_message" msgid="1970374898263063836">"Došlo je do problema pri isključivanju USB pohrane. Provjerite jeste li uklonili USB host, a zatim pokušajte ponovo."</string>
    <string name="dlg_confirm_kill_storage_users_title" msgid="963039033470478697">"Uključi USB pohranjivanje"</string>
    <string name="dlg_confirm_kill_storage_users_text" msgid="5100428757107469454">"Ako uključite USB pohranu, neke aplikacije koje upotrebljavate zaustavit će se i možda neće biti dostupne dok ne isključite USB pohranu."</string>
    <string name="dlg_error_title" msgid="7323658469626514207">"Rad USB-a nije uspio"</string>
    <string name="dlg_ok" msgid="7376953167039865701">"U redu"</string>
    <string name="usb_mtp_notification_title" msgid="3699913097391550394">"Spojen kao medijski uređaj"</string>
    <string name="usb_ptp_notification_title" msgid="1960817192216064833">"Spojen kao fotoaparat"</string>
    <string name="usb_cd_installer_notification_title" msgid="6774712827892090754">"Spojen kao instalacijski program"</string>
    <string name="usb_accessory_notification_title" msgid="7848236974087653666">"Spojen na USB pribor"</string>
    <string name="usb_notification_message" msgid="2290859399983720271">"Dodirnite za ostale opcije USB-a"</string>
    <string name="extmedia_format_title" product="nosdcard" msgid="9020092196061007262">"Format. USB pohranu?"</string>
    <string name="extmedia_format_title" product="default" msgid="3648415921526526069">"Formatirati SD karticu?"</string>
    <string name="extmedia_format_message" product="nosdcard" msgid="3934016853425761078">"Sve datoteke pohranjene na vašoj USB pohrani bit će izbrisane. Ta se radnja ne može poništiti!"</string>
    <string name="extmedia_format_message" product="default" msgid="14131895027543830">"Svi podaci na kartici bit će izgubljeni."</string>
    <string name="extmedia_format_button_format" msgid="4131064560127478695">"Format"</string>
    <string name="adb_active_notification_title" msgid="6729044778949189918">"Priključen je alat za uklanjanje pogrešaka USB-om"</string>
    <string name="adb_active_notification_message" msgid="1016654627626476142">"Dodirnite da se onemogući otklanjanje pogrešaka USB-om."</string>
    <string name="select_input_method" msgid="8547250819326693584">"Promjena tipkovnice"</string>
    <string name="configure_input_methods" msgid="4769971288371946846">"Odaberi tipkovnice"</string>
    <string name="show_ime" msgid="9157568568695230830">"Prikaz način unosa"</string>
    <string name="hardware" msgid="7517821086888990278">"Hardver"</string>
    <string name="select_keyboard_layout_notification_title" msgid="1407367017263030773">"Odaberite izgled tipkovnice"</string>
    <string name="select_keyboard_layout_notification_message" msgid="4465907700449257063">"Dodirnite za odabir izgleda tipkovnice."</string>
    <string name="fast_scroll_alphabet" msgid="5433275485499039199">" ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="4030170524595123610">" 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="candidates_style" msgid="4333913089637062257"><u>"kandidati"</u></string>
    <string name="ext_media_checking_notification_title" product="nosdcard" msgid="3449816005351468560">"Pripremanje memorije USB"</string>
    <string name="ext_media_checking_notification_title" product="default" msgid="5457603418970994050">"Priprema SD kartice"</string>
    <string name="ext_media_checking_notification_message" msgid="8287319882926737053">"Traženje pogrešaka."</string>
    <string name="ext_media_nofs_notification_title" product="nosdcard" msgid="7788040745686229307">"Prazna memorija USB"</string>
    <string name="ext_media_nofs_notification_title" product="default" msgid="780477838241212997">"Prazna SD kartica"</string>
    <string name="ext_media_nofs_notification_message" product="nosdcard" msgid="7840121067427269500">"USB pohrana prazna je ili ima nepodržani datotečni sustav."</string>
    <string name="ext_media_nofs_notification_message" product="default" msgid="8641065641786923604">"SD kartica prazna je ili ima nepodržani datotečni sustav."</string>
    <string name="ext_media_unmountable_notification_title" product="nosdcard" msgid="2090046769532713563">"Oštećena USB memorija"</string>
    <string name="ext_media_unmountable_notification_title" product="default" msgid="6410723906019100189">"Oštećena SD kartica"</string>
    <string name="ext_media_unmountable_notification_message" product="nosdcard" msgid="1795917578395333280">"USB pohrana oštećena je. Pokušajte ju ponovo formatirati."</string>
    <string name="ext_media_unmountable_notification_message" product="default" msgid="1753898567525568253">"SD kartica oštećena je. Pokušajte ju ponovo formatirati."</string>
    <string name="ext_media_badremoval_notification_title" product="nosdcard" msgid="1661683031330951073">"Memorija USB nenadano uklonjena"</string>
    <string name="ext_media_badremoval_notification_title" product="default" msgid="6872152882604407837">"SD kartica neočekivano je uklonjena"</string>
    <string name="ext_media_badremoval_notification_message" product="nosdcard" msgid="4329848819865594241">"Isključite USB memoriju na siguran način prije uklanjanja kako biste izbjegli gubitak podataka."</string>
    <string name="ext_media_badremoval_notification_message" product="default" msgid="7260183293747448241">"SD karticu isključite na siguran način prije uklanjanja kako biste izbjegli gubitak podataka."</string>
    <string name="ext_media_safe_unmount_notification_title" product="nosdcard" msgid="3967973893270360230">"Sigurno uklanjanje memorije USB"</string>
    <string name="ext_media_safe_unmount_notification_title" product="default" msgid="6729801130790616200">"SD kartica može se ukloniti na siguran način"</string>
    <string name="ext_media_safe_unmount_notification_message" product="nosdcard" msgid="6142195361606493530">"USB memoriju možete sigurno ukloniti."</string>
    <string name="ext_media_safe_unmount_notification_message" product="default" msgid="568841278138377604">"Možete ukloniti SD karticu na siguran način."</string>
    <string name="ext_media_nomedia_notification_title" product="nosdcard" msgid="4486377230140227651">"Memorija USB uklonjena"</string>
    <string name="ext_media_nomedia_notification_title" product="default" msgid="8902518030404381318">"Uklonjena SD kartica"</string>
    <string name="ext_media_nomedia_notification_message" product="nosdcard" msgid="6921126162580574143">"Memorija USB uklonjena. Umetnite novi medij."</string>
    <string name="ext_media_nomedia_notification_message" product="default" msgid="3870120652983659641">"SD kartica je uklonjena. Umetnite novu."</string>
    <string name="activity_list_empty" msgid="1675388330786841066">"Nisu pronađene podudarne radnje."</string>
    <string name="permlab_pkgUsageStats" msgid="8787352074326748892">"statistika o upotrebi ažurirane komponente"</string>
    <string name="permdesc_pkgUsageStats" msgid="1106612424254277630">"Omogućuje aplikaciji promjenu prikupljene statistike upotrebe komponenata. Nije namijenjena uobičajenim aplikacijama."</string>
    <string name="permlab_copyProtectedData" msgid="4341036311211406692">"kopiranje sadržaja"</string>
    <string name="permdesc_copyProtectedData" msgid="4390697124288317831">"Omogućuje aplikaciji dozivanje usluge zadanog spremnika radi kopiranja sadržaja. Nije namijenjena uobičajenim aplikacijama."</string>
    <string name="permlab_route_media_output" msgid="1642024455750414694">"Usmjeravanje medijskog izlaza"</string>
    <string name="permdesc_route_media_output" msgid="4932818749547244346">"Aplikaciji omogućuje usmjeravanje medijskog izlaza na druge vanjske uređaje."</string>
    <string name="permlab_access_keyguard_secure_storage" msgid="7565552237977815047">"Pristup zaključanoj sigurnoj pohrani"</string>
    <string name="permdesc_access_keyguard_secure_storage" msgid="5866245484303285762">"Omogućuje aplikaciji pristupanje zaključanoj sigurnoj pohrani."</string>
    <string name="permlab_control_keyguard" msgid="172195184207828387">"Upravljanje prikazivanjem i skrivanjem zaključavanja tipkovnice"</string>
    <string name="permdesc_control_keyguard" msgid="3043732290518629061">"Omogućuje aplikaciji upravljanje zaključavanjem tipkovnice."</string>
    <string name="permlab_trust_listener" msgid="1765718054003704476">"Prati promjene pouzdanog stanja."</string>
    <string name="permdesc_trust_listener" msgid="8233895334214716864">"Omogućuje aplikaciji praćenje promjena pouzdanog stanja."</string>
    <string name="permlab_provide_trust_agent" msgid="5465587586091358316">"Pružanje agenta za pouzdanost."</string>
    <string name="permdesc_provide_trust_agent" msgid="3865702641053068148">"Omogućuje aplikaciji pružanje agenta za pouzdanost."</string>
    <string name="permlab_launch_trust_agent_settings" msgid="5859430082240410200">"Pokrenite izbornik postavki agenta za pouzdanost."</string>
    <string name="permdesc_launch_trust_agent_settings" msgid="8185142708644913381">"Aplikaciji dopušta pokretanje aktivnosti koja mijenja ponašanje agenta za pouzdanost."</string>
    <string name="permlab_bind_trust_agent_service" msgid="8242093169457695334">"Povezivanje s uslugom agenta za pouzdanost"</string>
    <string name="permdesc_bind_trust_agent_service" msgid="7041930026024507515">"Omogućuje aplikaciji povezivanje s uslugom agenta za pouzdanost."</string>
    <string name="permlab_recovery" msgid="3157024487744125846">"Interakcija s ažuriranjem i sustavom za oporavak"</string>
    <string name="permdesc_recovery" msgid="8511774533266359571">"Omogućuje aplikaciji interakciju sa sustavom za oporavak i ažuriranjima sustava."</string>
    <string name="permlab_manageMediaProjection" msgid="1120495449419929218">"Upravljanje projekcijskim sesijama multimedije"</string>
    <string name="permdesc_manageMediaProjection" msgid="8053759147529492856">"Aplikaciji omogućuje upravljanje projekcijskim sesijama multimedije. Ove sesije pružaju aplikacijama mogućnost snimanja zaslona i audiosadržaja. Uobičajene aplikacije vjerojatno neće trebati tu značajku."</string>
    <string name="permlab_readInstallSessions" msgid="6165432407628065939">"Čitanje sesija instaliranja"</string>
    <string name="permdesc_readInstallSessions" msgid="2049771699626019849">"Omogućuje aplikaciji čitanje sesija instaliranja. Aplikacija može vidjeti pojedinosti o aktivnim instaliranjima paketa."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="4070433208160063538">"Dodirnite dvaput za upravljanje zumiranjem"</string>
    <string name="gadget_host_error_inflating" msgid="4882004314906466162">"Widget nije moguće dodati."</string>
    <string name="ime_action_go" msgid="8320845651737369027">"Idi"</string>
    <string name="ime_action_search" msgid="658110271822807811">"Pretraži"</string>
    <string name="ime_action_send" msgid="2316166556349314424">"Pošalji"</string>
    <string name="ime_action_next" msgid="3138843904009813834">"Dalje"</string>
    <string name="ime_action_done" msgid="8971516117910934605">"Gotovo"</string>
    <string name="ime_action_previous" msgid="1443550039250105948">"Preth."</string>
    <string name="ime_action_default" msgid="2840921885558045721">"Pokreni"</string>
    <string name="dial_number_using" msgid="5789176425167573586">"Biraj broj\nkoristeći <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="4947405226788104538">"Stvori kontakt\nkoristeći <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="2106103817937859662">"Sljedeća aplikacija ili više njih zahtijevaju dozvolu za pristup vašem računu, sad i u budućnosti."</string>
    <string name="grant_credentials_permission_message_footer" msgid="3125211343379376561">"Dopuštate li taj zahtjev?"</string>
    <string name="grant_permissions_header_text" msgid="6874497408201826708">"Zahtjev za pristup"</string>
    <string name="allow" msgid="7225948811296386551">"Dopusti"</string>
    <string name="deny" msgid="2081879885755434506">"Odbij"</string>
    <string name="permission_request_notification_title" msgid="6486759795926237907">"Zatražena je dozvola"</string>
    <string name="permission_request_notification_with_subtitle" msgid="8530393139639560189">"Zatražena je dozvola\nza račun <xliff:g id="ACCOUNT">%s</xliff:g>."</string>
    <string name="forward_intent_to_owner" msgid="1207197447013960896">"Ovu aplikaciju upotrebljavate izvan svog radnog profila"</string>
    <string name="forward_intent_to_work" msgid="621480743856004612">"Upotrebljavate tu aplikaciju u radnom profilu"</string>
    <string name="input_method_binding_label" msgid="1283557179944992649">"Način unosa"</string>
    <string name="sync_binding_label" msgid="3687969138375092423">"Sinkronizacija"</string>
    <string name="accessibility_binding_label" msgid="4148120742096474641">"Pristupačnost"</string>
    <string name="wallpaper_binding_label" msgid="1240087844304687662">"Pozadinska slika"</string>
    <string name="chooser_wallpaper" msgid="7873476199295190279">"Promjena pozadinske slike"</string>
    <string name="notification_listener_binding_label" msgid="2014162835481906429">"Slušatelj obavijesti"</string>
    <string name="condition_provider_service_binding_label" msgid="1321343352906524564">"Davatalj uvjeta"</string>
    <string name="vpn_title" msgid="19615213552042827">"VPN aktiviran"</string>
    <string name="vpn_title_long" msgid="6400714798049252294">"Aplikacija <xliff:g id="APP">%s</xliff:g> aktivirala je VPN"</string>
    <string name="vpn_text" msgid="3011306607126450322">"Dodirnite za upravljanje mrežom."</string>
    <string name="vpn_text_long" msgid="6407351006249174473">"Povezan sa sesijom <xliff:g id="SESSION">%s</xliff:g>. Dodirnite za upravljanje mrežom."</string>
    <string name="vpn_lockdown_connecting" msgid="6443438964440960745">"Povezivanje s uvijek uključenom VPN mrežom…"</string>
    <string name="vpn_lockdown_connected" msgid="8202679674819213931">"Povezan s uvijek uključenom VPN mrežom"</string>
    <string name="vpn_lockdown_error" msgid="6009249814034708175">"Pogreška uvijek uključene VPN mreže"</string>
    <string name="vpn_lockdown_config" msgid="6415899150671537970">"Dodirnite za konfiguraciju"</string>
    <string name="upload_file" msgid="2897957172366730416">"Odaberite datoteku"</string>
    <string name="no_file_chosen" msgid="6363648562170759465">"Nema odabranih datoteka"</string>
    <string name="reset" msgid="2448168080964209908">"Ponovo postavi"</string>
    <string name="submit" msgid="1602335572089911941">"Pošalji"</string>
    <string name="car_mode_disable_notification_title" msgid="3164768212003864316">"Omogućen je način rada za automobil"</string>
    <string name="car_mode_disable_notification_message" msgid="8035230537563503262">"Dodirnite za izlaz iz načina rada u automobilu."</string>
    <string name="tethered_notification_title" msgid="3146694234398202601">"Ograničenje ili aktivan hotspot"</string>
    <string name="tethered_notification_message" msgid="6857031760103062982">"Dodirnite za postavljanje."</string>
    <string name="back_button_label" msgid="2300470004503343439">"Natrag"</string>
    <string name="next_button_label" msgid="1080555104677992408">"Dalje"</string>
    <string name="skip_button_label" msgid="1275362299471631819">"Preskoči"</string>
    <string name="no_matches" msgid="8129421908915840737">"Nema rezultata"</string>
    <string name="find_on_page" msgid="1946799233822820384">"Pronađi na stranici"</string>
    <plurals name="matches_found" formatted="false" msgid="1210884353962081884">
      <item quantity="one"><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="7217581640461922289">"Gotovo"</string>
    <string name="progress_unmounting" product="nosdcard" msgid="3923810448507612746">"Isključivanje USB pohrane..."</string>
    <string name="progress_unmounting" product="default" msgid="1327894998409537190">"Isključivanje SD kartice..."</string>
    <string name="progress_erasing" product="nosdcard" msgid="4521573321524340058">"Brisanje USB pohrane..."</string>
    <string name="progress_erasing" product="default" msgid="6596988875507043042">"Brisanje SD kartice..."</string>
    <string name="format_error" product="nosdcard" msgid="6299769563624776948">"Brisanje USB pohrane nije uspjelo."</string>
    <string name="format_error" product="default" msgid="7315248696644510935">"Brisanje SD kartice nije uspjelo."</string>
    <string name="media_bad_removal" msgid="7960864061016603281">"Kartica SD uklonjena je prije isključivanja."</string>
    <string name="media_checking" product="nosdcard" msgid="418188720009569693">"Memorija USB trenutačno se provjerava."</string>
    <string name="media_checking" product="default" msgid="7334762503904827481">"Kartica SD trenutno se provjerava."</string>
    <string name="media_removed" msgid="7001526905057952097">"Kartica SD uklonjena je."</string>
    <string name="media_shared" product="nosdcard" msgid="5830814349250834225">"USB memoriju trenutačno upotrebljava računalo."</string>
    <string name="media_shared" product="default" msgid="5706130568133540435">"Karticu SD trenutačno upotrebljava računalo."</string>
    <string name="media_unknown_state" msgid="729192782197290385">"Vanjski mediji u nepoznatom stanju."</string>
    <string name="share" msgid="1778686618230011964">"Dijeli"</string>
    <string name="find" msgid="4808270900322985960">"Pronađi"</string>
    <string name="websearch" msgid="4337157977400211589">"Pretraž. weba"</string>
    <string name="find_next" msgid="5742124618942193978">"Nađi sljedeće"</string>
    <string name="find_previous" msgid="2196723669388360506">"Nađi prethodno"</string>
    <string name="gpsNotifTicker" msgid="5622683912616496172">"Zahtjev za lokaciju koji upućuje <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="5446858717157416839">"Zahtjev za lokaciju"</string>
    <string name="gpsNotifMessage" msgid="1374718023224000702">"Zatražio <xliff:g id="NAME">%1$s</xliff:g> (<xliff:g id="SERVICE">%2$s</xliff:g>)"</string>
    <string name="gpsVerifYes" msgid="2346566072867213563">"Da"</string>
    <string name="gpsVerifNo" msgid="1146564937346454865">"Ne"</string>
    <string name="sync_too_many_deletes" msgid="5296321850662746890">"Prekoračeno je ograničenje za brisanje"</string>
    <string name="sync_too_many_deletes_desc" msgid="496551671008694245">"Postoji sljedeći broj izbrisanih stavki: <xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g> za vrstu sinkronizacije <xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g> i račun <xliff:g id="ACCOUNT_NAME">%3$s</xliff:g>. Što želite učiniti?"</string>
    <string name="sync_really_delete" msgid="2572600103122596243">"Izbriši ove stavke"</string>
    <string name="sync_undo_deletes" msgid="2941317360600338602">"Poništi brisanja"</string>
    <string name="sync_do_nothing" msgid="3743764740430821845">"Za sada nemoj ništa učiniti"</string>
    <string name="choose_account_label" msgid="5655203089746423927">"Odaberite račun"</string>
    <string name="add_account_label" msgid="2935267344849993553">"Dodajte račun"</string>
    <string name="add_account_button_label" msgid="3611982894853435874">"Dodaj račun"</string>
    <string name="number_picker_increment_button" msgid="2412072272832284313">"Povećavanje"</string>
    <string name="number_picker_decrement_button" msgid="476050778386779067">"Smanjivanje"</string>
    <string name="number_picker_increment_scroll_mode" msgid="3073101067441638428">"<xliff:g id="VALUE">%s</xliff:g> pritisnite i držite."</string>
    <string name="number_picker_increment_scroll_action" msgid="9101473045891835490">"Kliznite prema gore za povećavanje i prema dolje za smanjivanje."</string>
    <string name="time_picker_increment_minute_button" msgid="8865885114028614321">"Povećanje minuta"</string>
    <string name="time_picker_decrement_minute_button" msgid="6246834937080684791">"Smanjenje minuta"</string>
    <string name="time_picker_increment_hour_button" msgid="3652056055810223139">"Povećanje sati"</string>
    <string name="time_picker_decrement_hour_button" msgid="1377479863429214792">"Smanjenje sati"</string>
    <string name="time_picker_increment_set_pm_button" msgid="4147590696151230863">"Postavi PM"</string>
    <string name="time_picker_decrement_set_am_button" msgid="8302140353539486752">"Postavi AM"</string>
    <string name="date_picker_increment_month_button" msgid="5369998479067934110">"Povećanje mjeseca"</string>
    <string name="date_picker_decrement_month_button" msgid="1832698995541726019">"Smanjenje mjeseca"</string>
    <string name="date_picker_increment_day_button" msgid="7130465412308173903">"Povećanje dana"</string>
    <string name="date_picker_decrement_day_button" msgid="4131881521818750031">"Smanjenje dana"</string>
    <string name="date_picker_increment_year_button" msgid="6318697384310808899">"Povećanje godine"</string>
    <string name="date_picker_decrement_year_button" msgid="4482021813491121717">"Smanjenje godine"</string>
    <string name="keyboardview_keycode_alt" msgid="4856868820040051939">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="1203984017245783244">"Odustani"</string>
    <string name="keyboardview_keycode_delete" msgid="3337914833206635744">"Izbriši"</string>
    <string name="keyboardview_keycode_done" msgid="1992571118466679775">"Gotovo"</string>
    <string name="keyboardview_keycode_mode_change" msgid="4547387741906537519">"Promjena načina"</string>
    <string name="keyboardview_keycode_shift" msgid="2270748814315147690">"Shift"</string>
    <string name="keyboardview_keycode_enter" msgid="2985864015076059467">"Enter"</string>
    <string name="activitychooserview_choose_application" msgid="2125168057199941199">"Odabir aplikacije"</string>
    <string name="activitychooserview_choose_application_error" msgid="8624618365481126668">"Nije moguće pokrenuti aplikaciju <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="shareactionprovider_share_with" msgid="806688056141131819">"Dijeljenje sa"</string>
    <string name="shareactionprovider_share_with_application" msgid="5627411384638389738">"Dijeli s aplikacijom <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="415975056159262248">"Klizna ručka. Dodirnite i držite."</string>
    <string name="description_target_unlock_tablet" msgid="3833195335629795055">"Prijeđite prstima da biste otključali."</string>
    <string name="keyboard_headset_required_to_hear_password" msgid="7011927352267668657">"Priključite slušalice kako biste čuli izgovaranje tipki zaporke."</string>
    <string name="keyboard_password_character_no_headset" msgid="2859873770886153678">"Točka."</string>
    <string name="action_bar_home_description" msgid="5293600496601490216">"Kreni na početnu"</string>
    <string name="action_bar_up_description" msgid="2237496562952152589">"Kreni gore"</string>
    <string name="action_menu_overflow_description" msgid="2295659037509008453">"Više opcija"</string>
    <string name="action_bar_home_description_format" msgid="7965984360903693903">"%1$s, %2$s"</string>
    <string name="action_bar_home_subtitle_description_format" msgid="6985546530471780727">"%1$s, %2$s, %3$s"</string>
    <string name="storage_internal" msgid="4891916833657929263">"Interna pohrana"</string>
    <string name="storage_sd_card" msgid="3282948861378286745">"SD kartica"</string>
    <string name="storage_usb" msgid="3017954059538517278">"USB pohrana"</string>
    <string name="extract_edit_menu_button" msgid="8940478730496610137">"Uredi"</string>
    <string name="data_usage_warning_title" msgid="1955638862122232342">"Upozorenje o upotrebi podataka"</string>
    <string name="data_usage_warning_body" msgid="2814673551471969954">"Dod. za prikaz upotrebe i post."</string>
    <string name="data_usage_3g_limit_title" msgid="4361523876818447683">"Dost. ogr. 2G–3G prijenosa pod."</string>
    <string name="data_usage_4g_limit_title" msgid="4609566827219442376">"Dost. ogr. 4G prijenosa podataka"</string>
    <string name="data_usage_mobile_limit_title" msgid="557158376602636112">"Dost. ogr. mob. prijenosa podat."</string>
    <string name="data_usage_wifi_limit_title" msgid="5803363779034792676">"Dost. ogr. Wi-Fi prijenosa pod."</string>
    <string name="data_usage_limit_body" msgid="291731708279614081">"Podaci su pauz. za ostatak cikl."</string>
    <string name="data_usage_3g_limit_snoozed_title" msgid="7026739121138005231">"Prekoračeno ograničenje 2G-3G"</string>
    <string name="data_usage_4g_limit_snoozed_title" msgid="1106562779311209039">"Prekoračeno je ograničenje 4G podataka"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="4941346653729943789">"Limit mobilnih podataka premašen"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="8743856006384825974">"Prekorač. Wi-Fi ogranič. pod."</string>
    <string name="data_usage_limit_snoozed_body" msgid="7035490278298441767">"Veličina <xliff:g id="SIZE">%s</xliff:g> prelazi navedeno ograničenje."</string>
    <string name="data_usage_restricted_title" msgid="5965157361036321914">"Pozadinski podaci ograničeni"</string>
    <string name="data_usage_restricted_body" msgid="6741521330997452990">"Dodirnite za uklanjanje ograničenja."</string>
    <string name="ssl_certificate" msgid="6510040486049237639">"Sigurnosni certifikat"</string>
    <string name="ssl_certificate_is_valid" msgid="6825263250774569373">"Ovaj je certifikat valjan."</string>
    <string name="issued_to" msgid="454239480274921032">"Izdano za:"</string>
    <string name="common_name" msgid="2233209299434172646">"Zajednički naziv:"</string>
    <string name="org_name" msgid="6973561190762085236">"Organizacija:"</string>
    <string name="org_unit" msgid="7265981890422070383">"Organizacijska jedinica:"</string>
    <string name="issued_by" msgid="2647584988057481566">"Izdao:"</string>
    <string name="validity_period" msgid="8818886137545983110">"Vrijedi do:"</string>
    <string name="issued_on" msgid="5895017404361397232">"Izdano dana:"</string>
    <string name="expires_on" msgid="3676242949915959821">"Istječe dana:"</string>
    <string name="serial_number" msgid="758814067660862493">"Serijski broj:"</string>
    <string name="fingerprints" msgid="4516019619850763049">"Otisci prstiju:"</string>
    <string name="sha256_fingerprint" msgid="4391271286477279263">"SHA-256 otisak prsta:"</string>
    <string name="sha1_fingerprint" msgid="7930330235269404581">"SHA-1 otisak prsta:"</string>
    <string name="activity_chooser_view_see_all" msgid="4292569383976636200">"Prikaži sve"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="4710013864974040615">"Odabir aktivnosti"</string>
    <string name="share_action_provider_share_with" msgid="5247684435979149216">"Dijeljenje s"</string>
    <string name="list_delimeter" msgid="3975117572185494152">", "</string>
    <string name="sending" msgid="3245653681008218030">"Slanje..."</string>
    <string name="launchBrowserDefault" msgid="2057951947297614725">"Pokrenuti preglednik?"</string>
    <string name="SetupCallDefault" msgid="5834948469253758575">"Prihvatiti poziv?"</string>
    <string name="activity_resolver_use_always" msgid="8017770747801494933">"Uvijek"</string>
    <string name="activity_resolver_use_once" msgid="2404644797149173758">"Samo jednom"</string>
    <string name="activity_resolver_work_profiles_support" msgid="185598180676883455">"%1$s ne podržava radni profil"</string>
    <string name="default_audio_route_name" product="tablet" msgid="4617053898167127471">"Tabletno računalo"</string>
    <string name="default_audio_route_name" product="default" msgid="4239291273420140123">"Telefon"</string>
    <string name="default_audio_route_name_headphones" msgid="8119971843803439110">"Slušalice"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="6240602982276591864">"Zvučnici postolja"</string>
    <string name="default_media_route_name_hdmi" msgid="2450970399023478055">"HDMI"</string>
    <string name="default_audio_route_category_name" msgid="3722811174003886946">"Sustav"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="8575624030406771015">"Bluetooth zvuk"</string>
    <string name="wireless_display_route_description" msgid="9070346425023979651">"Bežični prikaz"</string>
    <string name="media_route_button_content_description" msgid="591703006349356016">"Emitiranje"</string>
    <string name="media_route_chooser_title" msgid="1751618554539087622">"Povezivanje s uređajem"</string>
    <string name="media_route_chooser_title_for_remote_display" msgid="3395541745872017583">"Emitiranje zaslona na uređaj"</string>
    <string name="media_route_chooser_searching" msgid="4776236202610828706">"Traženje uređaja…"</string>
    <string name="media_route_chooser_extended_settings" msgid="87015534236701604">"Postavke"</string>
    <string name="media_route_controller_disconnect" msgid="8966120286374158649">"Prekini vezu"</string>
    <string name="media_route_status_scanning" msgid="7279908761758293783">"Skeniranje..."</string>
    <string name="media_route_status_connecting" msgid="6422571716007825440">"Povezivanje..."</string>
    <string name="media_route_status_available" msgid="6983258067194649391">"Dostupno"</string>
    <string name="media_route_status_not_available" msgid="6739899962681886401">"Nije dostupno"</string>
    <string name="media_route_status_in_use" msgid="4533786031090198063">"U upotrebi"</string>
    <string name="display_manager_built_in_display_name" msgid="2583134294292563941">"Ugrađeni zaslon"</string>
    <string name="display_manager_hdmi_display_name" msgid="1555264559227470109">"HDMI zaslon"</string>
    <string name="display_manager_overlay_display_name" msgid="5142365982271620716">"Preklapanje br. <xliff:g id="ID">%1$d</xliff:g>"</string>
    <string name="display_manager_overlay_display_title" msgid="652124517672257172">"<xliff:g id="NAME">%1$s</xliff:g>: <xliff:g id="WIDTH">%2$d</xliff:g> x <xliff:g id="HEIGHT">%3$d</xliff:g>, <xliff:g id="DPI">%4$d</xliff:g> dpi"</string>
    <string name="display_manager_overlay_display_secure_suffix" msgid="6022119702628572080">", sigurno"</string>
    <string name="kg_emergency_call_label" msgid="684946192523830531">"Hitan poziv"</string>
    <string name="kg_forgot_pattern_button_text" msgid="8852021467868220608">"Zaboravili ste obrazac"</string>
    <string name="kg_wrong_pattern" msgid="1850806070801358830">"Pogrešan obrazac"</string>
    <string name="kg_wrong_password" msgid="2333281762128113157">"Pogrešna zaporka"</string>
    <string name="kg_wrong_pin" msgid="1131306510833563801">"Pogrešan PIN"</string>
    <string name="kg_too_many_failed_attempts_countdown" msgid="6358110221603297548">"Pokušajte ponovo za <xliff:g id="NUMBER">%1$d</xliff:g> s."</string>
    <string name="kg_pattern_instructions" msgid="398978611683075868">"Iscrtajte svoj obrazac"</string>
    <string name="kg_sim_pin_instructions" msgid="2319508550934557331">"Unesite PIN za SIM"</string>
    <string name="kg_pin_instructions" msgid="2377242233495111557">"Unesite PIN"</string>
    <string name="kg_password_instructions" msgid="5753646556186936819">"Unesite zaporku"</string>
    <string name="kg_puk_enter_puk_hint" msgid="453227143861735537">"SIM je sad onemogućen. Unesite PUK kôd da biste nastavili. Kontaktirajte operatera za pojedinosti."</string>
    <string name="kg_puk_enter_pin_hint" msgid="7871604527429602024">"Upišite željeni PIN kôd"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="325676184762529976">"Potvrdite željeni PIN kôd"</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8950398016976865762">"Otključavanje SIM kartice…"</string>
    <string name="kg_password_wrong_pin_code" msgid="1139324887413846912">"Netočan PIN kôd."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="8795159358110620001">"Unesite PIN koji ima od 4 do 8 brojeva."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="6025069204539532000">"PUK kôd mora se sastojati od 8 brojeva."</string>
    <string name="kg_invalid_puk" msgid="3638289409676051243">"Ponovo unesite ispravan PUK kôd. Ponovljeni pokušaji trajno će onemogućiti SIM."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="7003469261464593516">"PIN kodovi nisu jednaki"</string>
    <string name="kg_login_too_many_attempts" msgid="6486842094005698475">"Previše pokušaja iscrtavanja obrasca"</string>
    <string name="kg_login_instructions" msgid="1100551261265506448">"Za otključavanje prijavite se Google računom."</string>
    <string name="kg_login_username_hint" msgid="5718534272070920364">"Korisničko ime (e-pošta)"</string>
    <string name="kg_login_password_hint" msgid="9057289103827298549">"Zaporka"</string>
    <string name="kg_login_submit_button" msgid="5355904582674054702">"Prijava"</string>
    <string name="kg_login_invalid_input" msgid="5754664119319872197">"Nevažeće korisničko ime ili zaporka."</string>
    <string name="kg_login_account_recovery_hint" msgid="5690709132841752974">"Zaboravili ste korisničko ime ili zaporku?\nPosjetite "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="kg_login_checking_password" msgid="1052685197710252395">"Provjera računa..."</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="8276745642049502550">"Netočno ste napisali PIN <xliff:g id="NUMBER_0">%d</xliff:g> puta. \n\nPokušajte ponovo za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="7813713389422226531">"Netočno ste napisali zaporku <xliff:g id="NUMBER_0">%d</xliff:g> puta. \n\nPokušajte ponovo za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="74089475965050805">"Netočno ste iscrtali obrazac za otključavanje <xliff:g id="NUMBER_0">%d</xliff:g> puta. \n\nPokušajte ponovo za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="1575557200627128949">"Netočno ste pokušali otključati tabletno računalo <xliff:g id="NUMBER_0">%d</xliff:g> puta. Ono će se vratiti na tvorničke postavke i svi korisnički podaci bit će izgubljeni nakon još ovoliko neuspjelih pokušaja: <xliff:g id="NUMBER_1">%d</xliff:g>."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="4051015943038199910">"Netočno ste pokušali otključati telefon <xliff:g id="NUMBER_0">%d</xliff:g> puta. On će se vratiti na tvorničke postavke i svi korisnički podaci bit će izgubljeni nakon još ovoliko neuspjelih pokušaja: <xliff:g id="NUMBER_1">%d</xliff:g>."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="2072996269148483637">"Netočno ste pokušali otključati tabletno računalo <xliff:g id="NUMBER">%d</xliff:g> puta. Sada će se vratiti na tvorničke postavke."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="4817627474419471518">"Netočno ste pokušali otključati telefon <xliff:g id="NUMBER">%d</xliff:g> puta. Sada će se vratiti na tvorničke postavke."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="3253575572118914370">"Netočno ste iscrtali obrazac za otključavanje <xliff:g id="NUMBER_0">%d</xliff:g> puta. Nakon još ovoliko neuspješnih pokušaja: <xliff:g id="NUMBER_1">%d</xliff:g> morat ćete otključati tabletno računalo pomoću računa e-pošte.\n\n Pokušajte ponovo za <xliff:g id="NUMBER_2">%d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="1437638152015574839">"Netočno ste iscrtali obrazac za otključavanje <xliff:g id="NUMBER_0">%d</xliff:g> puta. Nakon još ovoliko neuspješnih pokušaja: <xliff:g id="NUMBER_1">%d</xliff:g> morat ćete otključati telefon pomoću računa e-pošte.\n\n Pokušajte ponovo za <xliff:g id="NUMBER_2">%d</xliff:g> s."</string>
    <string name="kg_text_message_separator" product="default" msgid="4160700433287233771">" – "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="7899202978204438708">"Ukloni"</string>
    <string name="safe_media_volume_warning" product="default" msgid="2276318909314492312">"Želite li pojačati zvuk iznad preporučene razine?\n\nDugotrajno slušanje glasne glazbe može vam oštetiti sluh."</string>
    <string name="continue_to_enable_accessibility" msgid="1626427372316070258">"Nastavite držati s dva prsta kako biste omogućili pristupačnost."</string>
    <string name="accessibility_enabled" msgid="1381972048564547685">"Pristupačnost je omogućena."</string>
    <string name="enable_accessibility_canceled" msgid="3833923257966635673">"Pristupačnost otkazana."</string>
    <string name="user_switched" msgid="3768006783166984410">"Trenutačni korisnik <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="user_switching_message" msgid="2871009331809089783">"Prebacivanje na korisnika <xliff:g id="NAME">%1$s</xliff:g>…"</string>
    <string name="owner_name" msgid="2716755460376028154">"Vlasnik"</string>
    <string name="error_message_title" msgid="4510373083082500195">"Pogreška"</string>
    <string name="error_message_change_not_allowed" msgid="1347282344200417578">"Vaš administrator ne dopušta tu promjenu"</string>
    <string name="app_not_found" msgid="3429141853498927379">"Nije pronađena aplikacija za upravljanje ovom radnjom"</string>
    <string name="revoke" msgid="5404479185228271586">"Opozovi"</string>
    <string name="mediasize_iso_a0" msgid="1994474252931294172">"ISO A0"</string>
    <string name="mediasize_iso_a1" msgid="3333060421529791786">"ISO A1"</string>
    <string name="mediasize_iso_a2" msgid="3097535991925798280">"ISO A2"</string>
    <string name="mediasize_iso_a3" msgid="3023213259314236123">"ISO A3"</string>
    <string name="mediasize_iso_a4" msgid="231745325296873764">"ISO A4"</string>
    <string name="mediasize_iso_a5" msgid="3484327407340865411">"ISO A5"</string>
    <string name="mediasize_iso_a6" msgid="4861908487129577530">"ISO A6"</string>
    <string name="mediasize_iso_a7" msgid="5890208588072936130">"ISO A7"</string>
    <string name="mediasize_iso_a8" msgid="4319425041085816612">"ISO A8"</string>
    <string name="mediasize_iso_a9" msgid="4882220529506432008">"ISO A9"</string>
    <string name="mediasize_iso_a10" msgid="2382866026365359391">"ISO A10"</string>
    <string name="mediasize_iso_b0" msgid="3651827147402009675">"ISO B0"</string>
    <string name="mediasize_iso_b1" msgid="6072859628278739957">"ISO B1"</string>
    <string name="mediasize_iso_b2" msgid="1348731852150380378">"ISO B2"</string>
    <string name="mediasize_iso_b3" msgid="2612510181259261379">"ISO B3"</string>
    <string name="mediasize_iso_b4" msgid="695151378838115434">"ISO B4"</string>
    <string name="mediasize_iso_b5" msgid="4863754285582212487">"ISO B5"</string>
    <string name="mediasize_iso_b6" msgid="5305816292139647241">"ISO B6"</string>
    <string name="mediasize_iso_b7" msgid="531673542602786624">"ISO B7"</string>
    <string name="mediasize_iso_b8" msgid="9164474595708850034">"ISO B8"</string>
    <string name="mediasize_iso_b9" msgid="282102976764774160">"ISO B9"</string>
    <string name="mediasize_iso_b10" msgid="4517141714407898976">"ISO B10"</string>
    <string name="mediasize_iso_c0" msgid="3103521357901591100">"ISO C0"</string>
    <string name="mediasize_iso_c1" msgid="1231954105985048595">"ISO C1"</string>
    <string name="mediasize_iso_c2" msgid="927702816980087462">"ISO C2"</string>
    <string name="mediasize_iso_c3" msgid="835154173518304159">"ISO C3"</string>
    <string name="mediasize_iso_c4" msgid="5095951985108194011">"ISO C4"</string>
    <string name="mediasize_iso_c5" msgid="1985397450332305739">"ISO C5"</string>
    <string name="mediasize_iso_c6" msgid="8147421924174693013">"ISO C6"</string>
    <string name="mediasize_iso_c7" msgid="8993994925276122950">"ISO C7"</string>
    <string name="mediasize_iso_c8" msgid="6871178104139598957">"ISO C8"</string>
    <string name="mediasize_iso_c9" msgid="7983532635227561362">"ISO C9"</string>
    <string name="mediasize_iso_c10" msgid="5040764293406765584">"ISO C10"</string>
    <string name="mediasize_na_letter" msgid="2841414839888344296">"Letter"</string>
    <string name="mediasize_na_gvrnmt_letter" msgid="5295836838862962809">"Government Letter"</string>
    <string name="mediasize_na_legal" msgid="8621364037680465666">"Legal"</string>
    <string name="mediasize_na_junior_legal" msgid="3309324162155085904">"Junior Legal"</string>
    <string name="mediasize_na_ledger" msgid="5567030340509075333">"Ledger"</string>
    <string name="mediasize_na_tabloid" msgid="4571735038501661757">"Tabloid"</string>
    <string name="mediasize_na_index_3x5" msgid="5182901917818625126">"Kartica indeksa 3 x 5"</string>
    <string name="mediasize_na_index_4x6" msgid="7687620625422312396">"Kartica indeksa 4 x 6"</string>
    <string name="mediasize_na_index_5x8" msgid="8834215284646872800">"Kartica indeksa 5 x 8"</string>
    <string name="mediasize_na_monarch" msgid="213639906956550754">"Monarch"</string>
    <string name="mediasize_na_quarto" msgid="835778493593023223">"Quarto"</string>
    <string name="mediasize_na_foolscap" msgid="1573911237983677138">"Foolscap"</string>
    <string name="mediasize_chinese_roc_8k" msgid="3626855847189438896">"ROC 8K"</string>
    <string name="mediasize_chinese_roc_16k" msgid="9182191577022943355">"ROC 16K"</string>
    <string name="mediasize_chinese_prc_1" msgid="4793232644980170500">"PRC 1"</string>
    <string name="mediasize_chinese_prc_2" msgid="5404109730975720670">"PRC 2"</string>
    <string name="mediasize_chinese_prc_3" msgid="1335092253339363526">"PRC 3"</string>
    <string name="mediasize_chinese_prc_4" msgid="9167997800486569834">"PRC 4"</string>
    <string name="mediasize_chinese_prc_5" msgid="845875168823541497">"PRC 5"</string>
    <string name="mediasize_chinese_prc_6" msgid="3220325667692648789">"PRC 6"</string>
    <string name="mediasize_chinese_prc_7" msgid="1776792138507038527">"PRC 7"</string>
    <string name="mediasize_chinese_prc_8" msgid="1417176642687456692">"PRC 8"</string>
    <string name="mediasize_chinese_prc_9" msgid="4785983473123798365">"PRC 9"</string>
    <string name="mediasize_chinese_prc_10" msgid="7847982299391851899">"PRC 10"</string>
    <string name="mediasize_chinese_prc_16k" msgid="262793383539980677">"PRC 16K"</string>
    <string name="mediasize_chinese_om_pa_kai" msgid="5256815579447959814">"Pa Kai"</string>
    <string name="mediasize_chinese_om_dai_pa_kai" msgid="7336412963441354407">"Dai Pa Kai"</string>
    <string name="mediasize_chinese_om_jurro_ku_kai" msgid="6324465444100490742">"Jurro Ku Kai"</string>
    <string name="mediasize_japanese_jis_b10" msgid="1787262845627694376">"JIS B10"</string>
    <string name="mediasize_japanese_jis_b9" msgid="3336035783663287470">"JIS B9"</string>
    <string name="mediasize_japanese_jis_b8" msgid="6195398299104345731">"JIS B8"</string>
    <string name="mediasize_japanese_jis_b7" msgid="1674621886902828884">"JIS B7"</string>
    <string name="mediasize_japanese_jis_b6" msgid="4170576286062657435">"JIS B6"</string>
    <string name="mediasize_japanese_jis_b5" msgid="4899297958100032533">"JIS B5"</string>
    <string name="mediasize_japanese_jis_b4" msgid="4213158129126666847">"JIS B4"</string>
    <string name="mediasize_japanese_jis_b3" msgid="8513715307410310696">"JIS B3"</string>
    <string name="mediasize_japanese_jis_b2" msgid="4777690211897131190">"JIS B2"</string>
    <string name="mediasize_japanese_jis_b1" msgid="4608142385457034603">"JIS B1"</string>
    <string name="mediasize_japanese_jis_b0" msgid="7587108366572243991">"JIS B0"</string>
    <string name="mediasize_japanese_jis_exec" msgid="5244075432263649068">"JIS Exec"</string>
    <string name="mediasize_japanese_chou4" msgid="4941652015032631361">"Chou4"</string>
    <string name="mediasize_japanese_chou3" msgid="6387319169263957010">"Chou3"</string>
    <string name="mediasize_japanese_chou2" msgid="1299112025415343982">"Chou2"</string>
    <string name="mediasize_japanese_hagaki" msgid="8070115620644254565">"Hagaki"</string>
    <string name="mediasize_japanese_oufuku" msgid="6049065587307896564">"Oufuku"</string>
    <string name="mediasize_japanese_kahu" msgid="6872696027560065173">"Kahu"</string>
    <string name="mediasize_japanese_kaku2" msgid="2359077233775455405">"Kaku2"</string>
    <string name="mediasize_japanese_you4" msgid="2091777168747058008">"You4"</string>
    <string name="mediasize_unknown_portrait" msgid="3088043641616409762">"Nepoznati portret"</string>
    <string name="mediasize_unknown_landscape" msgid="4876995327029361552">"Nepoznati pejzaž"</string>
    <string name="write_fail_reason_cancelled" msgid="7091258378121627624">"Otkazano"</string>
    <string name="write_fail_reason_cannot_write" msgid="8132505417935337724">"Pogreška prilikom pisanja sadržaja"</string>
    <string name="reason_unknown" msgid="6048913880184628119">"nepoznato"</string>
    <string name="reason_service_unavailable" msgid="7824008732243903268">"Usluga ispisa nije omogućena"</string>
    <string name="print_service_installed_title" msgid="2246317169444081628">"Instalirana je usluga <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="print_service_installed_message" msgid="5897362931070459152">"Dotaknite za omogućivanje"</string>
    <string name="restr_pin_enter_admin_pin" msgid="783643731895143970">"Unesite PIN administratora"</string>
    <string name="restr_pin_enter_pin" msgid="3395953421368476103">"Unesite PIN"</string>
    <string name="restr_pin_incorrect" msgid="8571512003955077924">"Netočno"</string>
    <string name="restr_pin_enter_old_pin" msgid="1462206225512910757">"Trenutačni PIN"</string>
    <string name="restr_pin_enter_new_pin" msgid="5959606691619959184">"Novi PIN"</string>
    <string name="restr_pin_confirm_pin" msgid="8501523829633146239">"Potvrdite novi PIN"</string>
    <string name="restr_pin_create_pin" msgid="8017600000263450337">"Izradite PIN za izmjenu ograničenja"</string>
    <string name="restr_pin_error_doesnt_match" msgid="2224214190906994548">"PIN-ovi se ne podudaraju. Pokušajte ponovo."</string>
    <string name="restr_pin_error_too_short" msgid="8173982756265777792">"PIN je prekratak. Mora imati barem 4 znamenke."</string>
    <plurals name="restr_pin_countdown" formatted="false" msgid="9061246974881224688">
      <item quantity="one">Pokušajte ponovo za <xliff:g id="COUNT">%d</xliff:g> sekundu</item>
      <item quantity="few">Pokušajte ponovo za <xliff:g id="COUNT">%d</xliff:g> sekunde</item>
      <item quantity="other">Pokušajte ponovo za <xliff:g id="COUNT">%d</xliff:g> sekundi</item>
    </plurals>
    <string name="restr_pin_try_later" msgid="973144472490532377">"Pokušajte ponovo kasnije"</string>
    <string name="immersive_mode_confirmation" msgid="7227416894979047467">"Prijeđite prstom s vrha prema dolje za izlaz iz cijelog zaslona."</string>
    <string name="done_label" msgid="2093726099505892398">"Gotovo"</string>
    <string name="hour_picker_description" msgid="6698199186859736512">"Kružni klizač sati"</string>
    <string name="minute_picker_description" msgid="8606010966873791190">"Kružni klizač minuta"</string>
    <string name="select_hours" msgid="6043079511766008245">"Odaberite sate"</string>
    <string name="select_minutes" msgid="3974345615920336087">"Odaberite minute"</string>
    <string name="day_picker_description" msgid="8990847925961297968">"Mreža dana u mjesecu"</string>
    <string name="year_picker_description" msgid="5524331207436052403">"Popis godina"</string>
    <string name="select_day" msgid="7774759604701773332">"Odaberite mjesec i dan"</string>
    <string name="select_year" msgid="7952052866994196170">"Odaberite godinu"</string>
    <string name="item_is_selected" msgid="949687401682476608">"Odabrana je stavka <xliff:g id="ITEM">%1$s</xliff:g>"</string>
    <string name="deleted_key" msgid="7659477886625566590">"Izbrisan je broj <xliff:g id="KEY">%1$s</xliff:g>"</string>
    <string name="managed_profile_label_badge" msgid="2355652472854327647">"<xliff:g id="LABEL">%1$s</xliff:g> za posao"</string>
    <string name="lock_to_app_toast" msgid="7570091317001980053">"Da biste otkvačili ovaj zaslon, istovremeno dodirnite i zadržite Natrag i Pregled."</string>
    <string name="lock_to_app_toast_accessible" msgid="8239120109365070664">"Da biste otkvačili ovaj zaslon, dodirnite i zadržite Pregled."</string>
    <string name="lock_to_app_toast_locked" msgid="8739004135132606329">"Zaslon je pričvršćen. Vaša organizacija ne dopušta otkvačivanje."</string>
    <string name="lock_to_app_title" msgid="1682643873107812874">"Želite li upotrijebiti prikvačivanje?"</string>
    <string name="lock_to_app_description" msgid="4120623404152035221">"Prikvačivanje zaslona blokira zaslon na jednom prikazu.\n\nDa biste otkvačili zaslon, istovremeno dodirnite i zadržite Natrag i Pregled."</string>
    <string name="lock_to_app_description_accessible" msgid="199664191087836099">"Prikvačivanje zaslona blokira zaslon na jednom prikazu.\n\nDa biste otkvačili zaslon, dodirnite i zadržite Pregled."</string>
    <string name="lock_to_app_negative" msgid="2259143719362732728">"NE, HVALA"</string>
    <string name="lock_to_app_positive" msgid="7085139175671313864">"POKRENI"</string>
    <string name="lock_to_app_start" msgid="6643342070839862795">"Zaslon je pričvršćen"</string>
    <string name="lock_to_app_exit" msgid="8598219838213787430">"Zaslon je otkvačen"</string>
    <string name="lock_to_app_unlock_pin" msgid="2552556656504331634">"Traži PIN radi otkvačivanja"</string>
    <string name="lock_to_app_unlock_pattern" msgid="4182192144797225137">"Traži uzorak za otključavanje radi otkvačivanja"</string>
    <string name="lock_to_app_unlock_password" msgid="6380979775916974414">"Traži zaporku radi otkvačivanja"</string>
    <string name="battery_saver_description" msgid="2510530476513605742">"Da bi se produljilo trajanje baterije, ušteda baterije smanjuje rad uređaja i ograničava vibraciju i većinu pozadinskih podataka. Aplikacije za e-poštu, slanje poruka i ostalo koje se oslanjaju na sinkronizaciju možda se neće ažurirati ako ih ne otvorite.\n\nUšteda baterije isključuje se automatski dok se uređaj puni."</string>
    <string name="downtime_condition_summary" msgid="8761776337475705749">"Dok razdoblje zastoja ne završi u <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <plurals name="zen_mode_duration_minutes" formatted="false" msgid="5127407202506485571">
      <item quantity="one">%d minutu</item>
      <item quantity="few">%d minute</item>
      <item quantity="other">%d minuta</item>
    </plurals>
    <plurals name="zen_mode_duration_hours" formatted="false" msgid="3938821308277433854">
      <item quantity="one">%d sat</item>
      <item quantity="few">%d sata</item>
      <item quantity="other">%d sati</item>
    </plurals>
    <string name="zen_mode_forever" msgid="4316804956488785559">"Neodređeno"</string>
</resources>
