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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="byteShort" msgid="8340973892742019101">"B"</string>
    <string name="kilobyteShort" msgid="7542884022844556968">"kB"</string>
    <string name="megabyteShort" msgid="6355851576770428922">"MB"</string>
    <string name="gigabyteShort" msgid="3259882455212193214">"GB"</string>
    <string name="terabyteShort" msgid="231613018159186962">"TB"</string>
    <string name="petabyteShort" msgid="5637816680144990219">"PB"</string>
    <string name="fileSizeSuffix" msgid="8897567456150907538">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="untitled" msgid="4638956954852782576">"&lt;Bez naslova&gt;"</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(Nema broja telefona)"</string>
    <string name="unknownName" msgid="6867811765370350269">"Nepoznato"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2660020990097733077">"Govorna pošta"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2850889754919584674">"MSISDN1"</string>
    <string name="mmiError" msgid="5154499457739052907">"Problem sa povezivanjem ili nevažeći MMI kôd."</string>
    <string name="mmiFdnError" msgid="5224398216385316471">"Operacija je ograničena samo na brojeve fiksnog biranja."</string>
    <string name="mmiErrorWhileRoaming" msgid="762488890299284230">"Nije moguće promijeniti postavke prosljeđivanja poziva s vašeg telefona dok ste u romingu."</string>
    <string name="serviceEnabled" msgid="8147278346414714315">"Usluga je omogućena."</string>
    <string name="serviceEnabledFor" msgid="6856228140453471041">"Usluga je omogućena za:"</string>
    <string name="serviceDisabled" msgid="1937553226592516411">"Usluga je onemogućena."</string>
    <string name="serviceRegistered" msgid="6275019082598102493">"Registracija je uspješno izvršena."</string>
    <string name="serviceErased" msgid="1288584695297200972">"Brisanje je uspješno izvršeno."</string>
    <string name="passwordIncorrect" msgid="7612208839450128715">"Netačna lozinka."</string>
    <string name="mmiComplete" msgid="8232527495411698359">"MMI kôd izvršen."</string>
    <string name="badPin" msgid="9015277645546710014">"Stari PIN koji ste unijeli nije ispravan."</string>
    <string name="badPuk" msgid="5487257647081132201">"PUK koji ste unijeli nije ispravan."</string>
    <string name="mismatchPin" msgid="609379054496863419">"PIN-ovi koje ste unijeli se ne podudaraju."</string>
    <string name="invalidPin" msgid="3850018445187475377">"Unesite PIN koji sadrži 4 do 8 brojeva."</string>
    <string name="invalidPuk" msgid="8761456210898036513">"Unesite PUK koji sadrži 8 ili više brojeva."</string>
    <string name="needPuk" msgid="919668385956251611">"SIM kartica je zaključana PUK-om. Unesite PUK kôd za otključavanje kartice."</string>
    <string name="needPuk2" msgid="4526033371987193070">"Unesite PUK2 kako biste deblokirali SIM karticu."</string>
    <string name="enablePin" msgid="209412020907207950">"Nije uspjelo. Prvo omogućite SIM/RUIM zaključavanje."</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 nego se SIM kartica zaključa.</item>
      <item quantity="few">Imate još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaja prije nego se SIM kartica zaključa.</item>
      <item quantity="other">Imate još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaja prije nego se SIM kartica zaključa.</item>
    </plurals>
    <string name="imei" msgid="2625429890869005782">"IMEI"</string>
    <string name="meid" msgid="4841221237681254195">"MEID"</string>
    <string name="ClipMmi" msgid="6952821216480289285">"ID dolaznog poziva"</string>
    <string name="ClirMmi" msgid="7784673673446833091">"ID odlaznog poziva"</string>
    <string name="ColpMmi" msgid="3065121483740183974">"Identifikacija povezane linije"</string>
    <string name="ColrMmi" msgid="4996540314421889589">"Ograničenje identifikacije povezane linije"</string>
    <string name="CfMmi" msgid="5123218989141573515">"Prosljeđivanje 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 lozinke"</string>
    <string name="PinMmi" msgid="3113117780361190304">"Promjena PIN-a"</string>
    <string name="CnipMmi" msgid="3110534680557857162">"Broj pozivaoca dostupan"</string>
    <string name="CnirMmi" msgid="3062102121430548731">"Broj pozivaoca zabranjen"</string>
    <string name="ThreeWCMmi" msgid="9051047170321190368">"Poziv između tri osobe"</string>
    <string name="RuacMmi" msgid="7827887459138308886">"Odbijanje neželjenih i dosadnih poziva"</string>
    <string name="CndMmi" msgid="3116446237081575808">"Isporuka broja pozivaoca"</string>
    <string name="DndMmi" msgid="1265478932418334331">"Ne ometaj"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="429415409145781923">"Prikaz ID-a pozivaoca u zadanim postavkama zabranjen. Sljedeći poziv: zabranjen"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="3092918006077864624">"Prikaz ID-a pozivaoca u zadanim postavkama zabranjen. Sljedeći poziv: nije zabranjen"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="6179425182856418465">"Prikaz ID-a pozivaoca u zadanim postavkama nije zabranjen. Sljedeći poziv: zabranjen"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2567998633124408552">"Prikaz ID-a pozivaoca u zadanim postavkama nije zabranjen. Sljedeći poziv: nije zabranjen"</string>
    <string name="serviceNotProvisioned" msgid="8614830180508686666">"Uslugu nije moguće koristiti."</string>
    <string name="CLIRPermanent" msgid="3377371145926835671">"Ne možete promijeniti postavke ID-a pozivaoca."</string>
    <string name="RestrictedOnDataTitle" msgid="5221736429761078014">"Nema usluge prijenosa podataka na mobilnoj mreži"</string>
    <string name="RestrictedOnEmergencyTitle" msgid="6855466023161191166">"Hitni pozivi su nedostupni"</string>
    <string name="RestrictedOnNormalTitle" msgid="3179574012752700984">"Nema usluge govornih poziva"</string>
    <string name="RestrictedOnAllVoiceTitle" msgid="8037246983606545202">"Nema glasovne usluge ili hitnih poziva"</string>
    <string name="RestrictedStateContent" msgid="6538703255570997248">"Privremeno isključio mobilni operater"</string>
    <string name="RestrictedStateContentMsimTemplate" msgid="673416791370248176">"Privremeno isključio mobilni operater za SIM <xliff:g id="SIMNUMBER">%d</xliff:g>"</string>
    <string name="NetworkPreferenceSwitchTitle" msgid="6982395015324165258">"Nije moguće dosegnuti mobilnu mrežu"</string>
    <string name="NetworkPreferenceSwitchSummary" msgid="509327194863482733">"Pokušajte promijeniti preferiranu mrežu. Dodirnite za promjenu."</string>
    <string name="EmergencyCallWarningTitle" msgid="813380189532491336">"Hitni pozivi su nedostupni"</string>
    <string name="EmergencyCallWarningSummary" msgid="1899692069750260619">"Nije moguće uspostaviti hitne pozive putem Wi‑Fi mreže"</string>
    <string name="notification_channel_network_alert" msgid="4427736684338074967">"Upozorenja"</string>
    <string name="notification_channel_call_forward" msgid="2419697808481833249">"Prosljeđivanje poziva"</string>
    <string name="notification_channel_emergency_callback" msgid="6686166232265733921">"Način rada za hitni povratni poziv"</string>
    <string name="notification_channel_mobile_data_status" msgid="4575131690860945836">"Status prijenosa podataka na mobilnoj mreži"</string>
    <string name="notification_channel_sms" msgid="3441746047346135073">"SMS poruke"</string>
    <string name="notification_channel_voice_mail" msgid="3954099424160511919">"Poruke govorne pošte"</string>
    <string name="notification_channel_wfc" msgid="2130802501654254801">"Pozivanje putem WiFi-ja"</string>
    <string name="notification_channel_sim" msgid="4052095493875188564">"Status SIM-a"</string>
    <string name="peerTtyModeFull" msgid="6165351790010341421">"Ravnopravni uređaj zatražio načina rada TTY FULL"</string>
    <string name="peerTtyModeHco" msgid="5728602160669216784">"Ravnopravni uređaj zatražio načina rada TTY HCO"</string>
    <string name="peerTtyModeVco" msgid="1742404978686538049">"Ravnopravni uređaj zatražio načina rada TTY VCO"</string>
    <string name="peerTtyModeOff" msgid="3280819717850602205">"Ravnopravni uređaj zatražio načina rada TTY OFF"</string>
    <string name="serviceClassVoice" msgid="1258393812335258019">"Govorna"</string>
    <string name="serviceClassData" msgid="872456782077937893">"Podatke"</string>
    <string name="serviceClassFAX" msgid="5566624998840486475">"Faks"</string>
    <string name="serviceClassSMS" msgid="2015460373701527489">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="4523454783498551468">"Asinhroni"</string>
    <string name="serviceClassDataSync" msgid="7530000519646054776">"Sinhroni"</string>
    <string name="serviceClassPacket" msgid="6991006557993423453">"Paket"</string>
    <string name="serviceClassPAD" msgid="3235259085648271037">"PAD"</string>
    <string name="roamingText0" msgid="7170335472198694945">"Uključen pokazatelj da je uređaj u roamingu"</string>
    <string name="roamingText1" msgid="5314861519752538922">"Isključen pokazatelj da je uređaj u roamingu"</string>
    <string name="roamingText2" msgid="8969929049081268115">"Pokazatelj da je uređaj u roamingu treperi"</string>
    <string name="roamingText3" msgid="5148255027043943317">"Izvan naselja"</string>
    <string name="roamingText4" msgid="8808456682550796530">"Izvan zgrade"</string>
    <string name="roamingText5" msgid="7604063252850354350">"Roaming - preferirani sistem"</string>
    <string name="roamingText6" msgid="2059440825782871513">"Roaming - sistem dostupan"</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 - sve usluge potpuno dostupne"</string>
    <string name="roamingText10" msgid="3992906999815316417">"Roaming - djelimična funkcionalnost usluga"</string>
    <string name="roamingText11" msgid="4154476854426920970">"Oznaka da je uređaj u roamingu uključena"</string>
    <string name="roamingText12" msgid="1189071119992726320">"Oznaka da je uređaj u roamingu ugašena"</string>
    <string name="roamingTextSearching" msgid="8360141885972279963">"Traženje usluge"</string>
    <string name="wfcRegErrorTitle" msgid="3855061241207182194">"Nije moguće postaviti pozivanje putem WiFi-ja"</string>
  <string-array name="wfcOperatorErrorAlertMessages">
    <item msgid="3910386316304772394">"Da biste pozivali i slali poruke koristeći WiFi mrežu, prvo zatražite od operatera da postavi tu uslugu. Zatim ponovo uključite pozivanje putem WiFi-ja u Postavkama. (Kôd greške: <xliff:g id="CODE">%1$s</xliff:g>)"</item>
  </string-array>
  <string-array name="wfcOperatorErrorNotificationMessages">
    <item msgid="7372514042696663278">"Došlo je do problema prilikom registracije pozivanja putem WiFi mreže kod vašeg operatera: <xliff:g id="CODE">%1$s</xliff:g>"</item>
  </string-array>
    <!-- no translation found for wfcSpnFormat_spn (4998685024207291232) -->
    <skip />
    <string name="wfcSpnFormat_spn_wifi_calling" msgid="136001023263502280">"<xliff:g id="SPN">%s</xliff:g> Pozivanje putem WiFi-ja"</string>
    <string name="wfcSpnFormat_spn_wifi_calling_vo_hyphen" msgid="1730997175789582756">"<xliff:g id="SPN">%s</xliff:g> Pozivanje putem WiFi-ja"</string>
    <string name="wfcSpnFormat_wlan_call" msgid="2533371081782489793">"WLAN poziv"</string>
    <string name="wfcSpnFormat_spn_wlan_call" msgid="2315240198303197168">"<xliff:g id="SPN">%s</xliff:g> WLAN poziv"</string>
    <string name="wfcSpnFormat_spn_wifi" msgid="6546481665561961938">"<xliff:g id="SPN">%s</xliff:g> WiFi"</string>
    <string name="wfcSpnFormat_wifi_calling_bar_spn" msgid="1726178784338466265">"Pozivanje putem WiFi-ja | <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_vowifi" msgid="4444638298656953681">"<xliff:g id="SPN">%s</xliff:g> VoWifi"</string>
    <string name="wfcSpnFormat_wifi_calling" msgid="4990486735013125329">"Pozivanje putem WiFi-ja"</string>
    <string name="wfcSpnFormat_wifi" msgid="1892673884655959773">"WiFi"</string>
    <string name="wfcSpnFormat_wifi_calling_wo_hyphen" msgid="1336669776254502831">"Pozivanje putem WIFi-ja"</string>
    <string name="wfcSpnFormat_vowifi" msgid="1765176406171272629">"VoWifi"</string>
    <string name="wifi_calling_off_summary" msgid="8720659586041656098">"Isključeno"</string>
    <string name="wfc_mode_wifi_preferred_summary" msgid="7335489823608689868">"Poziv putem WiFi-ja"</string>
    <string name="wfc_mode_cellular_preferred_summary" msgid="7081742743152286290">"Poziv putem mobilne mreže"</string>
    <string name="wfc_mode_wifi_only_summary" msgid="2379919155237869320">"Samo WiFi"</string>
    <string name="cfTemplateNotForwarded" msgid="1683685883841272560">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nije proslijeđen"</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> za <xliff:g id="TIME_DELAY">{2}</xliff:g> sekundi"</string>
    <string name="cfTemplateRegistered" msgid="5073237827620166285">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nije proslijeđen"</string>
    <string name="cfTemplateRegisteredTime" msgid="6781621964320635172">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Poziv nije proslijeđen"</string>
    <string name="fcComplete" msgid="3118848230966886575">"Kôd za posebne usluge potpun."</string>
    <string name="fcError" msgid="3327560126588500777">"Problem sa povezivanjem ili nevažeći kôd za posebne usluge."</string>
    <string name="httpErrorOk" msgid="1191919378083472204">"Uredu"</string>
    <string name="httpError" msgid="7956392511146698522">"Došlo je do greške na mreži."</string>
    <string name="httpErrorLookup" msgid="4711687456111963163">"Pronalaženje URL-a nije uspjelo."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="6299980280442076799">"Šema za autentifikaciju stranice nije podržana."</string>
    <string name="httpErrorAuth" msgid="1435065629438044534">"Došlo je do greške prilikom autentifikacije."</string>
    <string name="httpErrorProxyAuth" msgid="1788207010559081331">"Došlo je do greške prilikom autentifikacije preko proksi servera."</string>
    <string name="httpErrorConnect" msgid="8714273236364640549">"Povezivanje sa serverom nije uspjelo."</string>
    <string name="httpErrorIO" msgid="2340558197489302188">"Veza sa serverom nije uspostavljena. Pokušajte ponovo kasnije."</string>
    <string name="httpErrorTimeout" msgid="4743403703762883954">"Vrijeme za uspostavljanje veze sa serverom je isteklo."</string>
    <string name="httpErrorRedirectLoop" msgid="8679596090392779516">"Stranica sadrži prevelik broj preusmjeravanja na server."</string>
    <string name="httpErrorUnsupportedScheme" msgid="5015730812906192208">"Protokol nije podržan."</string>
    <string name="httpErrorFailedSslHandshake" msgid="96549606000658641">"Uspostavljanje sigurne veze nije uspjelo."</string>
    <string name="httpErrorBadUrl" msgid="3636929722728881972">"Greška pri otvaranju stranice zbog neispravnog URL-a."</string>
    <string name="httpErrorFile" msgid="2170788515052558676">"Pristupanje fajlu nije uspjelo."</string>
    <string name="httpErrorFileNotFound" msgid="6203856612042655084">"Pronalaženje traženog fajla nije uspjelo."</string>
    <string name="httpErrorTooManyRequests" msgid="1235396927087188253">"Trenutno se obrađuje previše zahtjeva. Pokušajte ponovo kasnije."</string>
    <string name="notification_title" msgid="8967710025036163822">"Greška u prijavi za račun <xliff:g id="ACCOUNT">%1$s</xliff:g>"</string>
    <string name="contentServiceSync" msgid="8353523060269335667">"Sinhronizacija"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="7036196943673524858">"Nije moguće sinhronizirati"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="4884451152168188763">"Pokušali ste izbrisati previše sadržaja iz kategorije <xliff:g id="CONTENT_TYPE">%s</xliff:g>."</string>
    <string name="low_memory" product="tablet" msgid="6494019234102154896">"Pohrana tableta je puna. Izbrišite fajlove kako biste oslobodili prostor."</string>
    <string name="low_memory" product="watch" msgid="4415914910770005166">"Prostor za gledanje je pun. Izbrišite neke fajlove da oslobodite prostor."</string>
    <string name="low_memory" product="tv" msgid="516619861191025923">"Prostor TV-a za pohranu je pun. Izbrišite neke fajlove da oslobodite prostor."</string>
    <string name="low_memory" product="default" msgid="3475999286680000541">"Pohrana telefona je puna. Izbrišite fajlove kako biste oslobodili prostor."</string>
    <plurals name="ssl_ca_cert_warning" formatted="false" msgid="5106721205300213569">
      <item quantity="one">Instalirane su ustanove za izdavanje certifikata</item>
      <item quantity="few">Instalirane su ustanove za izdavanje certifikata</item>
      <item quantity="other">Instalirane su ustanove za izdavanje certifikata</item>
    </plurals>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4475437862189850602">"Od nepoznate treće strane"</string>
    <string name="ssl_ca_cert_noti_by_administrator" msgid="3541729986326153557">"Administrator vašeg radnog profila"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="4030263497686867141">"Od <xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="work_profile_deleted" msgid="5005572078641980632">"Poslovni profil je obrisan"</string>
    <string name="work_profile_deleted_details" msgid="6307630639269092360">"Nedostaje aplikacija administratora za radni profil ili je neispravna. Zbog toga su vaš radni profil i povezani podaci izbrisani. Obratite administratoru za pomoć."</string>
    <string name="work_profile_deleted_description_dpm_wipe" msgid="8823792115612348820">"Radni profil više nije dostupan na ovom uređaju"</string>
    <string name="work_profile_deleted_reason_maximum_password_failure" msgid="8986903510053359694">"Previše puta ste pokušali otključati uređaj"</string>
    <string name="network_logging_notification_title" msgid="6399790108123704477">"Uređajem se upravlja."</string>
    <string name="network_logging_notification_text" msgid="7930089249949354026">"Vaša organizacija upravlja ovim uređajem i može pratiti mrežni saobraćaj. Dodirnite za detalje."</string>
    <string name="factory_reset_warning" msgid="5423253125642394387">"Uređaj će biti izbrisan"</string>
    <string name="factory_reset_message" msgid="9024647691106150160">"Nije moguće koristiti aplikaciju administratora. Potpuno će se izbrisati podaci na vašem uređaju.\n\nAko imate pitanja, obratite se administratoru svoje organizacije."</string>
    <string name="printing_disabled_by" msgid="8936832919072486965">"Štampanje je onemogućila aplikacija <xliff:g id="OWNER_APP">%s</xliff:g>."</string>
    <string name="me" msgid="6545696007631404292">"Ja"</string>
    <string name="power_dialog" product="tablet" msgid="8545351420865202853">"Opcije tableta"</string>
    <string name="power_dialog" product="tv" msgid="6153888706430556356">"Opcije za TV"</string>
    <string name="power_dialog" product="default" msgid="1319919075463988638">"Opcije telefona"</string>
    <string name="silent_mode" msgid="7167703389802618663">"Nečujni način rada"</string>
    <string name="turn_on_radio" msgid="3912793092339962371">"Uključi bežičnu vezu"</string>
    <string name="turn_off_radio" msgid="8198784949987062346">"Isključi bežičnu vezu"</string>
    <string name="screen_lock" msgid="799094655496098153">"Zaključavanje ekrana"</string>
    <string name="power_off" msgid="4266614107412865048">"Isključi telefon"</string>
    <string name="silent_mode_silent" msgid="319298163018473078">"Zvuk zvona isključen"</string>
    <string name="silent_mode_vibrate" msgid="7072043388581551395">"Zvuk zvona na vibraciji"</string>
    <string name="silent_mode_ring" msgid="8592241816194074353">"Zvuk zvona uključen"</string>
    <string name="reboot_to_update_title" msgid="6212636802536823850">"Ažuriranje sistema Android"</string>
    <string name="reboot_to_update_prepare" msgid="6305853831955310890">"Priprema za ažuriranje..."</string>
    <string name="reboot_to_update_package" msgid="3871302324500927291">"Obrađuje se paket ažuriranja..."</string>
    <string name="reboot_to_update_reboot" msgid="6428441000951565185">"Ponovno pokretanje......"</string>
    <string name="reboot_to_reset_title" msgid="4142355915340627490">"Vraćanje na fabričke postavke"</string>
    <string name="reboot_to_reset_message" msgid="2432077491101416345">"Ponovno pokretanje......"</string>
    <string name="shutdown_progress" msgid="2281079257329981203">"Isključivanje...…"</string>
    <string name="shutdown_confirm" product="tablet" msgid="3385745179555731470">"Vaš tablet će se isključiti."</string>
    <string name="shutdown_confirm" product="tv" msgid="476672373995075359">"TV ć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">"Telefon će se isključiti."</string>
    <string name="shutdown_confirm_question" msgid="2906544768881136183">"Želite li ugasiti telefon?"</string>
    <string name="reboot_safemode_title" msgid="7054509914500140361">"Ponovo pokreni uređaj u sigurnom načinu rada"</string>
    <string name="reboot_safemode_confirm" msgid="55293944502784668">"Želite li pokrenuti uređaj u sigurnom načinu rada? To će onemogućiti sve aplikacije trećih strana koje ste instalirali. One će biti obnovljene kada ponovo pokrenete uređaj."</string>
    <string name="recent_tasks_title" msgid="3691764623638127888">"Nedavni zadaci"</string>
    <string name="no_recent_tasks" msgid="8794906658732193473">"Nema nedavno pokrenutih aplikacija."</string>
    <string name="global_actions" product="tablet" msgid="408477140088053665">"Opcije tableta"</string>
    <string name="global_actions" product="tv" msgid="7240386462508182976">"Opcije za TV"</string>
    <string name="global_actions" product="default" msgid="2406416831541615258">"Opcije telefona"</string>
    <string name="global_action_lock" msgid="2844945191792119712">"Zaključavanje ekrana"</string>
    <string name="global_action_power_off" msgid="4471879440839879722">"Isključi telefon"</string>
    <string name="global_action_emergency" msgid="7112311161137421166">"Hitno"</string>
    <string name="global_action_bug_report" msgid="7934010578922304799">"Izvještaj o greškama"</string>
    <string name="global_action_logout" msgid="935179188218826050">"Završi sesiju"</string>
    <string name="global_action_screenshot" msgid="8329831278085426283">"Snimak ekrana"</string>
    <string name="bugreport_title" msgid="5981047024855257269">"Izvještaj o greškama"</string>
    <string name="bugreport_message" msgid="398447048750350456">"Ovim će se prikupljati informacije o trenutnom stanju uređaja, koji će biti poslani kao e-poruka. Može malo potrajati dok se izvještaj o greškama ne kreira i bude spreman za slanje. Budite strpljivi."</string>
    <string name="bugreport_option_interactive_title" msgid="8635056131768862479">"Interaktivni izvještaj"</string>
    <string name="bugreport_option_interactive_summary" msgid="229299488536107968">"Koristite ovu opciju u većini slučajeva. Ova opcija vam omogućava praćenje napretka izvještaja, unos dodatnih detalja o problemu i pravljenje snimaka ekrana. Moglo bi doći do izostavljanja nekih manje korištenih dijelova za čije prijavljivanje je potrebno dugo vremena."</string>
    <string name="bugreport_option_full_title" msgid="6354382025840076439">"Kompletan izvještaj"</string>
    <string name="bugreport_option_full_summary" msgid="7210859858969115745">"Koristite ovu opciju za minimalno ometanje sistema kada uređaj ne reagira ili je prespor, ili kada su vam potrebni svi dijelovi izvještaja. Ova opcija ne dozvoljava unos dodatnih detalja ili pravljenje dodatnih snimaka ekrana."</string>
    <plurals name="bugreport_countdown" formatted="false" msgid="6878900193900090368">
      <item quantity="one">Snimak ekrana za prijavu greške pravim za <xliff:g id="NUMBER_1">%d</xliff:g> sekundu.</item>
      <item quantity="few">Snimak ekrana za prijavu greške pravim za <xliff:g id="NUMBER_1">%d</xliff:g> sekunde.</item>
      <item quantity="other">Snimak ekrana za prijavu greške pravim za <xliff:g id="NUMBER_1">%d</xliff:g> sekundi.</item>
    </plurals>
    <string name="global_action_toggle_silent_mode" msgid="8219525344246810925">"Nečujni način rada"</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 avionu"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="2719557982608919750">"Uključen je način rada u avionu"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="5075070442854490296">"Način rada u avionu ugašen"</string>
    <string name="global_action_settings" msgid="1756531602592545966">"Postavke"</string>
    <string name="global_action_assist" msgid="3892832961594295030">"Pomoć"</string>
    <string name="global_action_voice_assist" msgid="7751191495200504480">"Glasovna pomoć"</string>
    <string name="global_action_lockdown" msgid="1099326950891078929">"Zaključavanje"</string>
    <string name="status_bar_notification_info_overflow" msgid="5301981741705354993">"999+"</string>
    <string name="notification_hidden_text" msgid="6351207030447943784">"Novo obavještenje"</string>
    <string name="notification_channel_virtual_keyboard" msgid="6969925135507955575">"Virtuelna tastatura"</string>
    <string name="notification_channel_physical_keyboard" msgid="7297661826966861459">"Fizička tastatura"</string>
    <string name="notification_channel_security" msgid="7345516133431326347">"Sigurnost"</string>
    <string name="notification_channel_car_mode" msgid="3553380307619874564">"Način rada u automobilu"</string>
    <string name="notification_channel_account" msgid="7577959168463122027">"Status računa"</string>
    <string name="notification_channel_developer" msgid="7579606426860206060">"Poruke za programere"</string>
    <string name="notification_channel_updates" msgid="4794517569035110397">"Ažuriranja"</string>
    <string name="notification_channel_network_status" msgid="5025648583129035447">"Status mreže"</string>
    <string name="notification_channel_network_alerts" msgid="2895141221414156525">"Mrežna upozorenja"</string>
    <string name="notification_channel_network_available" msgid="4531717914138179517">"Mreža je dostupna"</string>
    <string name="notification_channel_vpn" msgid="8330103431055860618">"Status VPN-a"</string>
    <string name="notification_channel_device_admin" msgid="8353118887482520565">"Upozorenja od IT administratora"</string>
    <string name="notification_channel_alerts" msgid="4496839309318519037">"Upozorenja"</string>
    <string name="notification_channel_retail_mode" msgid="6088920674914038779">"Prodajna demonstracija"</string>
    <string name="notification_channel_usb" msgid="9006850475328924681">"USB veza"</string>
    <string name="notification_channel_heavy_weight_app" msgid="6218742927792852607">"Pokrenuta aplikacija"</string>
    <string name="notification_channel_foreground_service" msgid="3931987440602669158">"Aplikacije koje troše bateriju"</string>
    <string name="foreground_service_app_in_background" msgid="1060198778219731292">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> troši bateriju"</string>
    <string name="foreground_service_apps_in_background" msgid="7175032677643332242">"Broj aplikacija koje troše bateriju: <xliff:g id="NUMBER">%1$d</xliff:g>"</string>
    <string name="foreground_service_tap_for_details" msgid="372046743534354644">"Dodirnite za detalje o potrošnji baterije i prijenosa podataka"</string>
    <string name="foreground_service_multiple_separator" msgid="4021901567939866542">"<xliff:g id="LEFT_SIDE">%1$s</xliff:g>, <xliff:g id="RIGHT_SIDE">%2$s</xliff:g>"</string>
    <string name="safeMode" msgid="2788228061547930246">"Siguran način rada"</string>
    <string name="android_system_label" msgid="6577375335728551336">"Android sistem"</string>
    <string name="user_owner_label" msgid="8836124313744349203">"Pređite na lični profil"</string>
    <string name="managed_profile_label" msgid="8947929265267690522">"Pređite na radni profil"</string>
    <string name="permgrouplab_contacts" msgid="3657758145679177612">"Kontakti"</string>
    <string name="permgroupdesc_contacts" msgid="6951499528303668046">"pristupa vašim kontaktima"</string>
    <string name="permgrouprequest_contacts" msgid="6032805601881764300">"Dozvoliti aplikaciji &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; da pristupa vašim kontaktima?"</string>
    <string name="permgrouplab_location" msgid="7275582855722310164">"Lokacija"</string>
    <string name="permgroupdesc_location" msgid="1346617465127855033">"pristupa lokaciji ovog uređaja"</string>
    <string name="permgrouprequest_location" msgid="3788275734953323491">"Dozvoliti aplikaciji &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; da pristupi lokaciji ovog uređaja?"</string>
    <string name="permgrouprequestdetail_location" msgid="1347189607421252902">"Aplikacija će imati pristup lokaciji isključivo dok je koristite"</string>
    <string name="permgroupbackgroundrequest_location" msgid="5039063878675613235">"Dozvoliti aplikaciji &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; pristup lokaciji uređaja &lt;b&gt;sve vrijeme&lt;/b&gt;?"</string>
    <string name="permgroupbackgroundrequestdetail_location" msgid="4597006851453417387">"Aplikacija trenutno može pristupati lokaciji isključivo dok je koristite"</string>
    <string name="permgrouplab_calendar" msgid="5863508437783683902">"Kalendar"</string>
    <string name="permgroupdesc_calendar" msgid="3889615280211184106">"pristupa vašem kalendaru"</string>
    <string name="permgrouprequest_calendar" msgid="289900767793189421">"Dozvoliti aplikaciji &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; da pristupi vašem kalendaru?"</string>
    <string name="permgrouplab_sms" msgid="228308803364967808">"SMS"</string>
    <string name="permgroupdesc_sms" msgid="4656988620100940350">"šalje i pregleda SMS poruke"</string>
    <string name="permgrouprequest_sms" msgid="7168124215838204719">"Dozvoliti aplikaciji &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; slanje i pregled SMS poruka?"</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Pohrana"</string>
    <string name="permgroupdesc_storage" msgid="637758554581589203">"pristupa slikama, medijskim fajlovima i fajlovima na vašem uređaju"</string>
    <string name="permgrouprequest_storage" msgid="7885942926944299560">"Dozvoliti aplikaciji &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; da pristupa fotografijama, medijima i fajlovima na vašem uređaju?"</string>
    <string name="permgrouplab_microphone" msgid="171539900250043464">"Mikrofon"</string>
    <string name="permgroupdesc_microphone" msgid="4988812113943554584">"snima zvuk"</string>
    <string name="permgrouprequest_microphone" msgid="9167492350681916038">"Dozvoliti aplikaciji &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; da snima zvuk?"</string>
    <string name="permgrouplab_activityRecognition" msgid="1565108047054378642">"Fizička aktivnost"</string>
    <string name="permgroupdesc_activityRecognition" msgid="6949472038320473478">"pristup vašoj fizičkoj aktivnosti"</string>
    <string name="permgrouprequest_activityRecognition" msgid="7626438016904799383">"Dopustiti aplikaciji &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; da pristupi informacijama o vašoj fizičkoj aktivnosti?"</string>
    <string name="permgrouplab_camera" msgid="4820372495894586615">"Kamera"</string>
    <string name="permgroupdesc_camera" msgid="3250611594678347720">"snima fotografije i videozapise"</string>
    <string name="permgrouprequest_camera" msgid="1299833592069671756">"Dozvoliti aplikaciji &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; da snima fotografije i videozapise?"</string>
    <string name="permgrouplab_calllog" msgid="8798646184930388160">"Zapisnici poziva"</string>
    <string name="permgroupdesc_calllog" msgid="3006237336748283775">"čitanje i pisanje zapisnika telefonskih poziva"</string>
    <string name="permgrouprequest_calllog" msgid="8487355309583773267">"Dozvoliti aplikaciji &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; da pristupa zapisnicima poziva?"</string>
    <string name="permgrouplab_phone" msgid="5229115638567440675">"Telefon"</string>
    <string name="permgroupdesc_phone" msgid="6234224354060641055">"poziva i upravlja pozivima"</string>
    <string name="permgrouprequest_phone" msgid="9166979577750581037">"Dozvoliti aplikaciji &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; da upućuje pozove i upravlja njima?"</string>
    <string name="permgrouplab_sensors" msgid="4838614103153567532">"Tjelesni senzori"</string>
    <string name="permgroupdesc_sensors" msgid="7147968539346634043">"pristupa podacima senzora o vašim vitalnim funkcijama"</string>
    <string name="permgrouprequest_sensors" msgid="6349806962814556786">"Dozvoliti aplikaciji &lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; pristup senzornim podacima o vašim vitalnim znacima?"</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="3901717936930170320">"Preuzima sadržaj prozora"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="3772225008605310672">"Pregleda sadržaj prozora koji trenutno koristite."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="3108723364676667320">"Uključi opciju Istraživanje dodirom"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="7543249041581408313">"Stavke koje dodirnete bit će izgovorene naglas, a ekran možete istraživati koristeći pokrete."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2103440391902412174">"Prati tekst koji unosite"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="7463135292204152818">"Obuhvata lične podatke kao što su brojevi kreditnih kartica i lozinke."</string>
    <string name="capability_title_canControlMagnification" msgid="3593493281059424855">"Kontrolira uvećavanje prikaza na ekranu"</string>
    <string name="capability_desc_canControlMagnification" msgid="4791858203568383773">"Kontrolira stepen uvećanja prikaza na ekranu i podešavanje položaja."</string>
    <string name="capability_title_canPerformGestures" msgid="7418984730362576862">"Praviti pokrete"</string>
    <string name="capability_desc_canPerformGestures" msgid="8296373021636981249">"Može dodirivati, prevlačiti, hvatati prstima i praviti druge pokrete."</string>
    <string name="capability_title_canCaptureFingerprintGestures" msgid="6309568287512278670">"Pokreti otiska prsta"</string>
    <string name="capability_desc_canCaptureFingerprintGestures" msgid="4386487962402228670">"Moguće je zabilježiti pokrete na senzoru za otisak prsta uređaja."</string>
    <string name="permlab_statusBar" msgid="7417192629601890791">"onemogućavanje ili mijenjanje statusne trake"</string>
    <string name="permdesc_statusBar" msgid="8434669549504290975">"Dozvoljava aplikaciji onemogućavanje statusne trake ili dodavanje i uklanjanje sistemskih ikona."</string>
    <string name="permlab_statusBarService" msgid="4826835508226139688">"funkcioniranje u vidu statusne trake"</string>
    <string name="permdesc_statusBarService" msgid="716113660795976060">"Dozvoljava aplikaciji da postane statusna traka."</string>
    <string name="permlab_expandStatusBar" msgid="1148198785937489264">"proširivanje/sužavanje statusne trake"</string>
    <string name="permdesc_expandStatusBar" msgid="6917549437129401132">"Dozvoljava aplikaciji proširivanje ili sužavanje statusne trake."</string>
    <string name="permlab_install_shortcut" msgid="4279070216371564234">"instaliranje prečica"</string>
    <string name="permdesc_install_shortcut" msgid="8341295916286736996">"Omogućava aplikaciji dodavanje prečice za početni ekran bez intervencije korisnika."</string>
    <string name="permlab_uninstall_shortcut" msgid="4729634524044003699">"uklanjanje prečica"</string>
    <string name="permdesc_uninstall_shortcut" msgid="6745743474265057975">"Omogućava aplikaciji uklanjanje prečice početnog ekrana bez intervencije korisnika."</string>
    <string name="permlab_processOutgoingCalls" msgid="3906007831192990946">"preusmjeravanje odlaznih poziva"</string>
    <string name="permdesc_processOutgoingCalls" msgid="5156385005547315876">"Dozvoljava aplikaciji da vidi birani broj prilikom odlaznog poziva uz opciju da poziv preusmjeri na drugi broj ili da ga skroz prekine."</string>
    <string name="permlab_answerPhoneCalls" msgid="4077162841226223337">"odgovor na telefonski poziv"</string>
    <string name="permdesc_answerPhoneCalls" msgid="2901889867993572266">"Omogućava aplikaciji odgovor na dolazni telefonski poziv."</string>
    <string name="permlab_receiveSms" msgid="8673471768947895082">"primanje tekstualnih poruka (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="6424387754228766939">"Omogućava aplikaciji primanje i obradu SMS poruka. Ovo znači da aplikacija može pratiti ili brisati poruke poslane na vaš uređaj, a da vam ih pritom ne prikazuje."</string>
    <string name="permlab_receiveMms" msgid="1821317344668257098">"primanje tekstualnih poruka (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="533019437263212260">"Omogućava aplikaciji prijem i obradu MMS poruka. Ovo znači da aplikacija može pratiti ili brisati poruke poslane na vaš uređaj, a da vam ih pritom ne prikazuje."</string>
    <string name="permlab_readCellBroadcasts" msgid="1598328843619646166">"čitanje poruka info servisa"</string>
    <string name="permdesc_readCellBroadcasts" msgid="6361972776080458979">"Omogućava aplikaciji čitanje poruka info servisa koje je primio vaš uređaj. Upozorenja koja emitira info servis se isporučuju na nekim lokacijama kako bi vas upozorila na vanredne situacije. Zlonamjerne aplikacije mogu ometati performanse ili rad vašeg uređaja kada primite informaciju o vanrednoj situaciji od info servisa."</string>
    <string name="permlab_subscribedFeedsRead" msgid="4756609637053353318">"čitanje sadržaja na koje ste pretplaćeni"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="5557058907906144505">"Dozvoljava aplikaciji prikupljanje detalja o trenutno sinhroniziranim sadržajima."</string>
    <string name="permlab_sendSms" msgid="7544599214260982981">"slanje i pregledanje SMS poruka"</string>
    <string name="permdesc_sendSms" msgid="7094729298204937667">"Omogućava aplikaciji slanje SMS poruka. Ovo može dovesti do neočekivanih troškova. Zlonamjerne aplikacije mogu trošiti vaš novac tako što će slati poruke bez vašeg znanja."</string>
    <string name="permlab_readSms" msgid="8745086572213270480">"čitanje vaših tekstualnih poruka (SMS ili MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="4741697454888074891">"Ova aplikacija može čitati sve SMS (tekstualne) poruke pohranjene na vašem tabletu."</string>
    <string name="permdesc_readSms" product="tv" msgid="5796670395641116592">"Ova aplikacija može čitati sve SMS (tekstualne) poruke pohranjene na vašem TV-u."</string>
    <string name="permdesc_readSms" product="default" msgid="6826832415656437652">"Ova aplikacija može čitati sve SMS (tekstualne) poruke pohranjene na vašem telefonu."</string>
    <string name="permlab_receiveWapPush" msgid="5991398711936590410">"primanje tekstualnih poruka (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="748232190220583385">"Omogućava aplikaciji primanje i obradu WAP poruka. Ovo znači da aplikacija može pratiti ili brisati poruke poslane na vaš uređaj, a da vam ih pritom ne prikazuje."</string>
    <string name="permlab_getTasks" msgid="6466095396623933906">"preuzimanje informacija o pokrenutim aplikacijama"</string>
    <string name="permdesc_getTasks" msgid="7454215995847658102">"Omogućava aplikaciji preuzimanje informacija o trenutnim i nedavno pokrenutim zadacima. Ovo može omogućiti aplikaciji da otkrije informacije o aplikacijama korištenim na uređaju."</string>
    <string name="permlab_manageProfileAndDeviceOwners" msgid="7918181259098220004">"upravljanje vlasnicima profila i uređaja"</string>
    <string name="permdesc_manageProfileAndDeviceOwners" msgid="106894851498657169">"Omogućava aplikaciji da postavi vlasnike profila i vlasnika uređaja."</string>
    <string name="permlab_reorderTasks" msgid="2018575526934422779">"izmjena rasporeda pokrenutih aplikacija"</string>
    <string name="permdesc_reorderTasks" msgid="7734217754877439351">"Omogućava aplikaciji pomjeranje zadataka u prvi plan i pozadinu. Aplikacija ovo može učiniti bez vašeg učešća."</string>
    <string name="permlab_enableCarMode" msgid="5684504058192921098">"omogućavanje načina rada u autu"</string>
    <string name="permdesc_enableCarMode" msgid="4853187425751419467">"Dozvoljava aplikaciji da omogući način rada u autu."</string>
    <string name="permlab_killBackgroundProcesses" msgid="3914026687420177202">"zatvaranje drugih aplikacija"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="4593353235959733119">"Omogućava aplikaciji prekid pozadinskih procesa drugih aplikacija. Ovo može dovesti do prestanka rada drugih aplikacija."</string>
    <string name="permlab_systemAlertWindow" msgid="7238805243128138690">"Ova aplikacija se može pojaviti iznad drugih aplikacija"</string>
    <string name="permdesc_systemAlertWindow" msgid="2393776099672266188">"Aplikacija se može pojaviti iznad ostalih aplikacija ili drugih dijelova ekrana. To može uticati na normalno korištenje aplikacije i promijeniti izgled drugih aplikacija."</string>
    <string name="permlab_runInBackground" msgid="7365290743781858803">"rad u pozadini"</string>
    <string name="permdesc_runInBackground" msgid="7370142232209999824">"Ova aplikacija može raditi u pozadini. To može brže istrošiti bateriju."</string>
    <string name="permlab_useDataInBackground" msgid="8694951340794341809">"prijenos podataka u pozadini"</string>
    <string name="permdesc_useDataInBackground" msgid="6049514223791806027">"Ova aplikacija može prenositi podatke u pozadini. To može povećati prijenos podataka."</string>
    <string name="permlab_persistentActivity" msgid="8841113627955563938">"podešavanje aplikacije tako da je uvijek pokrenuta"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="8525189272329086137">"Omogućava aplikaciji da neke svoje dijelove pohrani trajno u memoriji. Ovo može ograničiti veličinu raspoložive memorije za druge aplikacije i tako usporiti tablet."</string>
    <string name="permdesc_persistentActivity" product="tv" msgid="5086862529499103587">"Dozvoljava aplikaciji da jednim dijelom trajno ostaje u memoriji. Time se ostalim aplikacijama dostupna memorija može ograničiti te usporiti rad TV-a."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="4384760047508278272">"Omogućava aplikaciji da neke svoje dijelove pohrani trajno u memoriji. Ovo može ograničiti veličinu raspoložive memorije za druge aplikacije i tako usporiti telefon."</string>
    <string name="permlab_foregroundService" msgid="3310786367649133115">"pokretanje usluge u prvom planu"</string>
    <string name="permdesc_foregroundService" msgid="6471634326171344622">"Dopušta aplikaciji korištenje usluga u prvom planu."</string>
    <string name="permlab_getPackageSize" msgid="7472921768357981986">"mjerenje prostora kojeg aplikacije zauzimaju u pohrani"</string>
    <string name="permdesc_getPackageSize" msgid="3921068154420738296">"Dozvoljava aplikaciji preuzimanje svog koda, podataka i veličine keš memorije"</string>
    <string name="permlab_writeSettings" msgid="2226195290955224730">"izmjena postavki sistema"</string>
    <string name="permdesc_writeSettings" msgid="7775723441558907181">"Dozvoljava aplikaciji izmijenu postavki sistema. Zlonamjerne aplikacije mogu oštetiti konfiguraciju sistema."</string>
    <string name="permlab_receiveBootCompleted" msgid="5312965565987800025">"pokrenuti pri pokretanju"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="7390304664116880704">"Dozvoljava aplikaciji da se sama pokrene čim sistem završi pokretanje. Zbog toga pokretanje tableta može trajati duže i to može omogućiti aplikaciji da uspori rad čitavog tableta svojim neprekidnim radom."</string>
    <string name="permdesc_receiveBootCompleted" product="tv" msgid="4525890122209673621">"Dozvoljava aplikaciji samostalno pokretanje odmah nakon pokretanja sistema. Ovim se vrijeme pokretanja TV-a može produžiti, a aplikaciji se omogućava da uspori rad tableta tako što je stalno aktivna."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="513950589102617504">"Dozvoljava aplikaciji da se sama pokrene čim sistem završi pokretanje. Zbog toga pokretanje telefona može trajati duže i to može omogućiti aplikaciji da uspori rad čitavog telefona svojim neprekidnim radom."</string>
    <string name="permlab_broadcastSticky" msgid="7919126372606881614">"slanje ljepljivih informacija"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="7749760494399915651">"Omogućava aplikaciji slanje ljepljivih informacija koje ostaju nakon prestanka emitiranja. Njihova pretjerana upotreba može usporiti ili destabilizirati rad tableta jer troši previše memorije."</string>
    <string name="permdesc_broadcastSticky" product="tv" msgid="6839285697565389467">"Dozvoljava aplikaciji slanje ljepljivih informacija koje ostaju nakon prestanka emitiranja. Pretjeranom upotrebom može se usporiti ili destabilizirati rad TV-a zbog korištenja previše memorije."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="2825803764232445091">"Omogućava aplikaciji slanje ljepljivih informacija koje ostaju nakon prestanka emitiranja. Njihova pretjerana upotreba može usporiti ili destabilizirati rad telefona jer troši previše memorije."</string>
    <string name="permlab_readContacts" msgid="8348481131899886131">"čitanje vaših kontakata"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="5294866856941149639">"Omogućava aplikaciji čitanje podataka o kontaktima koji su pohranjeni na vašem tabletu, uključujući učestalost vaših poziva, slanja e-pošte ili nekog drugog vida komunikacije sa određenim pojedincima. Ovo odobrenje omogućava aplikacijama da pohrane podatke o vašim kontaktima tako da ih zlonamjerne aplikacije mogu podijeliti bez vašeg znanja."</string>
    <string name="permdesc_readContacts" product="tv" msgid="1839238344654834087">"Dozvoljava aplikaciji da čita podatke o vašim kontaktima pohranjenim na TV-u, uključujući učestalost poziva, slanja e-pošte ili komuniciranja na bilo koji način s određenim osobama. Ovim odobrenjem aplikacijama se omogućava da sačuvaju podatke o kontaktima, a zlonamjerne aplikacije mogu bez vašeg znanja podijeliti ove podatke."</string>
    <string name="permdesc_readContacts" product="default" msgid="8440654152457300662">"Omogućava aplikaciji čitanje podataka o kontaktima koji su pohranjeni na vašem telefonu, uključujući učestalost vaših poziva, slanja e-pošte ili nekog drugog vida komunikacije sa određenim pojedincima. Ovo odobrenje omogućava aplikacijama da pohrane podatke o vašim kontaktima tako da ih zlonamjerne aplikacije mogu podijeliti bez vašeg znanja."</string>
    <string name="permlab_writeContacts" msgid="5107492086416793544">"izmjena podataka o kontaktima"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="897243932521953602">"Omogućava aplikaciji da izmijeni podatke o kontaktima koji su pohranjeni na vašem tabletu, uključujući učestalost vaših poziva, slanje e-pošte, ili neki drugi vid komunikacije sa određenim kontaktima. Ovo odobrenje omogućava aplikaciji da obriše podatke o kontaktima."</string>
    <string name="permdesc_writeContacts" product="tv" msgid="5438230957000018959">"Dozvoljava aplikaciji izmjenu podataka o vašim kontaktima pohranjenim na TV-u, uključujući učestalost poziva, slanja e-pošte ili komuniciranja na bilo koji način s određenim kontaktima. Ovim odobrenjem aplikacijama se omogućava brisanje podataka o kontaktima."</string>
    <string name="permdesc_writeContacts" product="default" msgid="589869224625163558">"Omogućava aplikaciji da izmijeni podatke o kontaktima koji su pohranjeni na vašem telefonu, uključujući učestalost vaših poziva, slanje e-pošte, ili neki drugi vid komunikacije sa određenim kontaktima. Ovo odobrenje omogućava aplikaciji da izbriše podatke o kontaktima."</string>
    <string name="permlab_readCallLog" msgid="3478133184624102739">"čitanje zapisnika poziva"</string>
    <string name="permdesc_readCallLog" msgid="3204122446463552146">"Ova aplikacija može čitati historiju vaših poziva."</string>
    <string name="permlab_writeCallLog" msgid="8552045664743499354">"pisanje zapisnika poziva"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="6661806062274119245">"Omogućava aplikaciji da izmijeni zapisnik poziva sa vašeg tableta, uključujući podatke o dolaznim i odlaznim pozivima. Zlonamjerne aplikacije mogu to iskoristiti za brisanje ili izmjenu vašeg zapisnika poziva."</string>
    <string name="permdesc_writeCallLog" product="tv" msgid="4225034892248398019">"Dozvoljava aplikaciji izmjenu evidencije poziva s TV-a, uključujući podatke o dolaznim i odlaznim pozivima. Zlonamjerne aplikacije mogu to iskoristiti za brisanje ili izmjenu evidencije poziva."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="683941736352787842">"Omogućava aplikaciji da izmijeni zapisnik poziva sa vašeg telefona, uključujući podatke o dolaznim i odlaznim pozivima. Zlonamjerne aplikacije mogu to iskoristiti za brisanje ili izmjenu vašeg zapisnika poziva."</string>
    <string name="permlab_bodySensors" msgid="4683341291818520277">"pristup tjelesnim senzorima (poput monitora za puls)"</string>
    <string name="permdesc_bodySensors" product="default" msgid="4380015021754180431">"Dozvoljava aplikaciji pristup podacima sa senzora koji prate fizičke pokazatelje kao što je vaš puls."</string>
    <string name="permlab_readCalendar" msgid="6716116972752441641">"Čitanje događaja kalendara i detalja"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="4993979255403945892">"Ova aplikacija može čitati sve događaje u kalendaru pohranjene na vašem tabletu i sačuvati podatke kalendara."</string>
    <string name="permdesc_readCalendar" product="tv" msgid="8837931557573064315">"Ova aplikacija može čitati sve događaje u kalendaru na vašem TV-u i dijeliti ili sačuvati podatke kalendara."</string>
    <string name="permdesc_readCalendar" product="default" msgid="4373978642145196715">"Ova aplikacija može čitati sve događaje u kalendaru pohranjene na vašem telefonu i sačuvati podatke kalendara."</string>
    <string name="permlab_writeCalendar" msgid="8438874755193825647">"dodavanje ili izmjena kalendarskih događaja i slanje e-pošte gostima bez znanja vlasnika"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="1675270619903625982">"Ova aplikacija može dodavati, uklanjati ili mijenjati događaje u kalendaru na vašem tabletu. Aplikacija može slati poruke koje mogu izgledati kao da dolazi od vlasnika kalendara ili promijeniti događaje bez obavještenja vlasnika."</string>
    <string name="permdesc_writeCalendar" product="tv" msgid="9017809326268135866">"Ova aplikacija može dodavati, uklanjati ili mijenjati događaje u kalendaru na vašem TV-u. Aplikacija može slati poruke koje mogu izgledati kao da dolazi od vlasnika kalendara ili promijeniti događaje bez obavještenja vlasnika."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="7592791790516943173">"Ova aplikacija može dodavati, uklanjati ili mijenjati događaje u kalendaru na vašem telefonu. Aplikacija može slati poruke koje mogu izgledati kao da dolazi od vlasnika kalendara ili promijeniti događaje bez obavještenja vlasnika."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"pristup dodatnim informacijama o lokaciji"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="6078307221056649927">"Dozvoljava aplikaciji pristup dodatnim naredbama pružatelja lokacija. Ovim se aplikaciji može dozvoliti da ometa rad GPS-a ili drugih izvora lokacija."</string>
    <string name="permlab_accessFineLocation" msgid="6265109654698562427">"pristup tačnoj lokaciji samo u prvom planu"</string>
    <string name="permdesc_accessFineLocation" msgid="3520508381065331098">"Ova aplikacija može odrediti vašu tačnu lokaciju samo kada je u prvom planu. Ove usluge lokacije moraju biti uključene i dostupne na vašem telefonu da ih aplikacija može koristiti. To može dovesti do povećane potrošnje baterije."</string>
    <string name="permlab_accessCoarseLocation" msgid="3707180371693213469">"pristup približnoj lokaciji (utvrđena preko mreže) samo u prvom planu"</string>
    <string name="permdesc_accessCoarseLocation" product="tablet" msgid="8594719010575779120">"Ova aplikacija može odrediti vašu lokaciju na osnovu izvora mreže kao što su predajnici za mobilnu mrežu i WiFi mreže ali samo kada je aplikacija u prvom planu. Ove usluge za određivanje lokacije moraju biti uključene i omogućene na vašem tabletu kako bi ih aplikacija mogla koristiti."</string>
    <string name="permdesc_accessCoarseLocation" product="tv" msgid="3027871910200890806">"Ova aplikacija može odrediti vašu lokaciju na osnovu izvora mreže kao što su predajnici za mobilnu mrežu i WiFi mreže ali samo kada je aplikacija u prvom planu. Ove usluge za određivanje lokacije moraju biti uključene i omogućene na vašem TV uređaju kako bi ih aplikacija mogla koristiti."</string>
    <string name="permdesc_accessCoarseLocation" product="default" msgid="854896049371048754">"Ova aplikacija može odrediti vašu lokaciju na osnovu izvora mreže kao što su predajnici za mobilnu mrežu i WiFi mreže ali samo kada je aplikacija u prvom planu. Ove usluge za određivanje lokacije moraju biti uključene i omogućene na vašem telefonu kako bi ih aplikacija mogla koristiti."</string>
    <string name="permlab_accessBackgroundLocation" msgid="3965397804300661062">"pristup lokaciji u pozadini"</string>
    <string name="permdesc_accessBackgroundLocation" msgid="1096394429579210251">"Ako je ovo odobreno, pored pristupa približnoj ili tačnoj lokaciji, aplikacija može pristupiti lokaciji dok radi u pozadini."</string>
    <string name="permlab_modifyAudioSettings" msgid="6095859937069146086">"izmjene postavki zvuka"</string>
    <string name="permdesc_modifyAudioSettings" msgid="3522565366806248517">"Omogućava aplikaciji izmjenu općih postavki zvuka, kao što su jačina zvuka i izbor izlaznog zvučnika."</string>
    <string name="permlab_recordAudio" msgid="3876049771427466323">"snimanje audiozapisa"</string>
    <string name="permdesc_recordAudio" msgid="4245930455135321433">"Ova aplikacija može u svakom trenutku snimati zvuk koristeći mikrofon."</string>
    <string name="permlab_sim_communication" msgid="2935852302216852065">"slanje komandi SIM kartici"</string>
    <string name="permdesc_sim_communication" msgid="5725159654279639498">"Omogućava aplikaciji slanje naredbi na SIM. Ovo je vrlo opasno."</string>
    <string name="permlab_activityRecognition" msgid="3634590230567608356">"prepoznavanje fizičke aktivnosti"</string>
    <string name="permdesc_activityRecognition" msgid="3143453925156552894">"Ova aplikacija može prepoznati vašu fizičku aktivnost."</string>
    <string name="permlab_camera" msgid="3616391919559751192">"snimanje slika i videozapisa"</string>
    <string name="permdesc_camera" msgid="5392231870049240670">"Ova aplikacija može slikati fotografije i snimati videozapise koristeći kameru bilo kada."</string>
    <string name="permlab_vibrate" msgid="7696427026057705834">"kontrola vibracije"</string>
    <string name="permdesc_vibrate" msgid="6284989245902300945">"Dozvoljava aplikaciji upravljanje vibracijom."</string>
    <string name="permlab_callPhone" msgid="3925836347681847954">"izravno zvanje telefonskih brojeva"</string>
    <string name="permdesc_callPhone" msgid="3740797576113760827">"Omogućava aplikaciji pozivanje telefonskih brojeva bez vašeg angažiranja. Ovo može uzrokovati neočekivane troškove ili pozive. Imajte na umu da ovo ne daje aplikaciji mogućnost pozivanja brojeva za hitne slučajeve. Zlonamjerne aplikacije vam mogu napraviti neočekivane troškove kroz vršenje poziva bez vašeg znanja."</string>
    <string name="permlab_accessImsCallService" msgid="3574943847181793918">"pristup usluzi IMS pozivanja"</string>
    <string name="permdesc_accessImsCallService" msgid="8992884015198298775">"Omogućava aplikaciji da koristi IMS uslugu za pozivanje bez vaše intervencije."</string>
    <string name="permlab_readPhoneState" msgid="9178228524507610486">"čitanje statusa i identiteta telefona"</string>
    <string name="permdesc_readPhoneState" msgid="1639212771826125528">"Omogućava aplikaciji pristup telefonskim funkcijama uređaja. Ovo odobrenje omogućava aplikaciji određivanje telefonskog i identifikacionog broja uređaja, bez obzira da li je poziv aktivan i da li je uspostavljena veza sa pozivanim brojem."</string>
    <string name="permlab_manageOwnCalls" msgid="1503034913274622244">"usmjeravanje poziva preko sistema"</string>
    <string name="permdesc_manageOwnCalls" msgid="6552974537554717418">"Dopušta aplikaciji da pozive usmjeri preko sistema radi poboljšanja iskustva pozivanja."</string>
    <string name="permlab_callCompanionApp" msgid="3599252979411970473">"vidjeti i kontrolirati pozive preko sistema."</string>
    <string name="permdesc_callCompanionApp" msgid="4567344683275099090">"Dozvoljava aplikaciji da vidi i kontrolira odlazne pozive na uređaju. To uključuje informacije kao što su brojevi telefona i stanja poziva."</string>
    <string name="permlab_acceptHandover" msgid="2661534649736022409">"nastavlja poziv iz druge aplikacije"</string>
    <string name="permdesc_acceptHandovers" msgid="4570660484220539698">"Dozvoljava aplikaciji nastavljanje poziva koji je započet u drugoj aplikaciji."</string>
    <string name="permlab_readPhoneNumbers" msgid="6108163940932852440">"čitanje telefonskih brojeva"</string>
    <string name="permdesc_readPhoneNumbers" msgid="8559488833662272354">"Dozvoljava aplikaciji pristup telefonskim brojevima uređaja."</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1531731435011495015">"sprečavanje tableta da uđe u režim mirovanja"</string>
    <string name="permlab_wakeLock" product="tv" msgid="2601193288949154131">"spriječi ulazak TV-a u režim mirovanja"</string>
    <string name="permlab_wakeLock" product="default" msgid="573480187941496130">"sprečavanje telefona da uđe u režim mirovanja"</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="7311319824400447868">"Dozvoljava aplikaciji da spriječi tablet da ode u stanje mirovanja."</string>
    <string name="permdesc_wakeLock" product="tv" msgid="3208534859208996974">"Dozvoljava aplikaciji da spriječi ulazak TV-a u režim mirovanja."</string>
    <string name="permdesc_wakeLock" product="default" msgid="8559100677372928754">"Dozvoljava aplikaciji da spriječi telefon da ode u stanje mirovanja."</string>
    <string name="permlab_transmitIr" msgid="7545858504238530105">"prijenos putem infracrvenog odašiljača"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5358308854306529170">"Omogućava aplikaciji korištenje infracrvenog odašiljača tableta."</string>
    <string name="permdesc_transmitIr" product="tv" msgid="3926790828514867101">"Dozvoljava aplikaciji korištenje infracrvenog predajnika na TV-u."</string>
    <string name="permdesc_transmitIr" product="default" msgid="7957763745020300725">"Omogućava aplikaciji korištenje infracrvenog odašiljača telefona."</string>
    <string name="permlab_setWallpaper" msgid="6627192333373465143">"postavljanje pozadinske slike"</string>
    <string name="permdesc_setWallpaper" msgid="7373447920977624745">"Dozvoljava aplikaciji postavljanje sistemske pozadinske slike."</string>
    <string name="permlab_setWallpaperHints" msgid="3278608165977736538">"prilagođavanje veličine pozadinske slike"</string>
    <string name="permdesc_setWallpaperHints" msgid="8235784384223730091">"Dozvoljava aplikaciji određivanje veličine sistemske pozadinske slike."</string>
    <string name="permlab_setTimeZone" msgid="2945079801013077340">"postavljanje vremenske zone"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1676983712315827645">"Dozvoljava aplikaciji promjenu vremenske zone tableta."</string>
    <string name="permdesc_setTimeZone" product="tv" msgid="888864653946175955">"Dozvoljava aplikaciji promjenu vremenske zone na TV-u."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4499943488436633398">"Dozvoljava aplikaciji promjenu vremenske zone telefona."</string>
    <string name="permlab_getAccounts" msgid="1086795467760122114">"pronalaženje računa na uređaju"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="2741496534769660027">"Omogućava aplikaciji dobijanje spiska računa koje tablet prepoznaje. Spisak može uključivati sve račune koje su kreirale instalirane aplikacije."</string>
    <string name="permdesc_getAccounts" product="tv" msgid="4190633395633907543">"Dozvoljava aplikaciji da preuzme spisak računa koje TV prepoznaje. To može obuhvatiti sve račune koji su napravljeni pomoću aplikacija koje ste instalirali."</string>
    <string name="permdesc_getAccounts" product="default" msgid="3448316822451807382">"Omogućava aplikaciji dobijanje spiska računa koje telefon prepoznaje. Spisak može uključivati sve račune koje su kreirale instalirane aplikacije."</string>
    <string name="permlab_accessNetworkState" msgid="4951027964348974773">"prikaz mrežnih veza"</string>
    <string name="permdesc_accessNetworkState" msgid="8318964424675960975">"Omogućava aplikaciji pregled informacija o mrežnim vezama, npr. koje mreže postoje i koje su povezane."</string>
    <string name="permlab_createNetworkSockets" msgid="7934516631384168107">"ima potpuni pristup mreži"</string>
    <string name="permdesc_createNetworkSockets" msgid="3403062187779724185">"Omogućava aplikaciji kreiranje spojnih tačaka s mrežom i korištenje prilagođenih mrežnih protokola. Preglednik i druge aplikacije omogućavaju slanje podataka na internet, tako da ovo odobrenje nije potrebno za vršenje te radnje."</string>
    <string name="permlab_changeNetworkState" msgid="958884291454327309">"izmjene povezivanja na mrežu"</string>
    <string name="permdesc_changeNetworkState" msgid="6789123912476416214">"Dozvoljava aplikaciji izmjenu stanja mrežne povezanosti."</string>
    <string name="permlab_changeTetherState" msgid="5952584964373017960">"izmjene podijeljenog povezivanja"</string>
    <string name="permdesc_changeTetherState" msgid="1524441344412319780">"Dozvoljava aplikaciji izmjenu stanja povezanosti na podijeljenu mrežu."</string>
    <string name="permlab_accessWifiState" msgid="5202012949247040011">"pregled WiFi veza"</string>
    <string name="permdesc_accessWifiState" msgid="5002798077387803726">"Omogućava aplikaciji pregled informacija o WiFi mrežama, npr. je li WiFi omogućen i imena povezanih WiFi uređaja."</string>
    <string name="permlab_changeWifiState" msgid="6550641188749128035">"uspostavljanje i prekidanje WiFi veze"</string>
    <string name="permdesc_changeWifiState" msgid="7137950297386127533">"Omogućava aplikaciji uspostavljanje i prekidanje veze sa WiFi pristupnim tačkama, kao i promjenu konfiguracije uređaja za WiFi mreže."</string>
    <string name="permlab_changeWifiMulticastState" msgid="1368253871483254784">"dozvoljava prijem paketa kroz WiFi Multicast"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="7969774021256336548">"Omogućava aplikaciji prijem paketa poslanih svim uređajima na WiFi mreži pomoću multicast tehnologije, a ne samo na vaš tablet. Troši više energije nego rad van multicast načina rada."</string>
    <string name="permdesc_changeWifiMulticastState" product="tv" msgid="9031975661145014160">"Omogućava aplikaciji prijem paketa poslanih svim uređajima na WiFi mreži pomoću multicast tehnologije, a ne samo na vaš TV. Troši više energije nego rad van multicast načina rada."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="6851949706025349926">"Omogućava aplikaciji prijem paketa poslanih svim uređajima na WiFi mreži pomoću multicast tehnologije, a ne samo na vaš telefon. Troši više energije nego rad van multicast načina rada."</string>
    <string name="permlab_bluetoothAdmin" msgid="6006967373935926659">"pristup Bluetooth postavkama"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="6921177471748882137">"Dozvoljava aplikaciji konfiguriranje lokalnog Bluetooth tableta te otkrivanje udaljenih uređaja i sparivanje s njima."</string>
    <string name="permdesc_bluetoothAdmin" product="tv" msgid="3373125682645601429">"Dozvoljava aplikaciji konfiguriranje lokalnog Bluetooth TV-a te otkrivanje i povezivanje s udaljenim uređajima."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="8931682159331542137">"Dozvoljava aplikaciji konfiguriranje lokalnog Bluetooth telefona te otkrivanje udaljenih uređaja i sparivanje s njima."</string>
    <string name="permlab_accessWimaxState" msgid="4195907010610205703">"uspostavljanje i prekidanje veze sa WiMAX mrežama"</string>
    <string name="permdesc_accessWimaxState" msgid="6360102877261978887">"Dozvoljava aplikaciji da utvrdi da li je WiMAX omogućen i informacije o bilo kojoj WiMAX mreži koja je povezana."</string>
    <string name="permlab_changeWimaxState" msgid="340465839241528618">"izmjene stanja WiMAX signala"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="3156456504084201805">"Omogućava aplikaciji uspostavljanje i prekidanje veze tableta sa WiMAX mrežama."</string>
    <string name="permdesc_changeWimaxState" product="tv" msgid="6022307083934827718">"Dozvoljava aplikaciji da TV poveže na WiMAX mreže ili da ga isključi s njih."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="697025043004923798">"Omogućava aplikaciji uspostavljanje i prekidanje veze telefona sa WiMAX mrežama."</string>
    <string name="permlab_bluetooth" msgid="6127769336339276828">"uparivanje sa Bluetooth uređajima"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3480722181852438628">"Omogućava aplikaciji prikaz konfiguracije za Bluetooth na tabletu, kao i uspostavljanje i prihvatanje veza sa uparenim uređajima."</string>
    <string name="permdesc_bluetooth" product="tv" msgid="3974124940101104206">"Dozvoljava aplikaciji prikaz konfiguracije Bluetooth veze na TV-u te uspostavljanje i prihvatanje veza s ravnopravnim uređajima."</string>
    <string name="permdesc_bluetooth" product="default" msgid="3207106324452312739">"Omogućava aplikaciji prikaz konfiguracije za Bluetooth na telefonu, kao i uspostavljanje i prihvatanje veza sa uparenim uređajima."</string>
    <string name="permlab_nfc" msgid="4423351274757876953">"upravljanje NFC-om"</string>
    <string name="permdesc_nfc" msgid="7120611819401789907">"Dozvoljava aplikaciji komuniciranje sa NFC (komunikacija bliskog polja) oznakama, karticama i čitačima."</string>
    <string name="permlab_disableKeyguard" msgid="3598496301486439258">"deaktivacija zaključavanja ekrana"</string>
    <string name="permdesc_disableKeyguard" msgid="6034203065077122992">"Omogućava aplikaciji deaktivaciju zaključane tastature i svih povezanih zaštita. Naprimjer, telefon deaktivira zaključavanje tastature kod dolaznog telefonskog poziva, a zatim ponovo aktivira zaključavanje tastature kada je poziv završen."</string>
    <string name="permlab_requestPasswordComplexity" msgid="202650535669249674">"zahtjev za kompleksnost zaključavanja ekrana"</string>
    <string name="permdesc_requestPasswordComplexity" msgid="4730994229754212347">"Omogućava aplikaciji da sazna nivo kompleksnosti zaključavanja ekrana (visoki, srednji, niski ili bez zaključavanja), što naznačava mogući raspon trajanja i vrste zaključavanja ekrana. Aplikacija također može korisnicima predložiti da ažuriraju zaključavanje ekrana do određenog nivoa, ali korisnici slobodno mogu ignorirati prijedlog i napustiti stranicu. Važno je napomenuti da se zaključavanje ekrana ne pohranjuje kao obični tekst tako da aplikacija ne zna tačnu lozinku."</string>
    <string name="permlab_useBiometric" msgid="8837753668509919318">"koristi biometrijski hardver za otiske prstij"</string>
    <string name="permdesc_useBiometric" msgid="8389855232721612926">"Omogućava aplikaciji da za autentifikaciju koristi biometrijski hardver"</string>
    <string name="permlab_manageFingerprint" msgid="5640858826254575638">"upravljanje hardverom za otiske prstiju"</string>
    <string name="permdesc_manageFingerprint" msgid="178208705828055464">"Omogućava aplikaciji da koristi metode za dodavanje i brisanje šablona otisaka prstiju za upotrebu."</string>
    <string name="permlab_useFingerprint" msgid="3150478619915124905">"korištenje hardvera za otiske prstiju"</string>
    <string name="permdesc_useFingerprint" msgid="9165097460730684114">"Omogućava aplikaciji da za autentifikaciju koristi hardver za otiske prstiju"</string>
    <string name="permlab_audioWrite" msgid="2661772059799779292">"izmjena muzičke kolekcije"</string>
    <string name="permdesc_audioWrite" msgid="8888544708166230494">"Omogućava aplikaciji da mijenja vašu muzičku kolekciju."</string>
    <string name="permlab_videoWrite" msgid="128769316366746446">"izmjena kolekcije videozapisa"</string>
    <string name="permdesc_videoWrite" msgid="5448565757490640841">"Omogućava aplikaciji da mijenja vašu kolekciju videozapisa."</string>
    <string name="permlab_imagesWrite" msgid="3391306186247235510">"izmjena kolekcije fotografija"</string>
    <string name="permdesc_imagesWrite" msgid="7073662756617474375">"Omogućava aplikaciji da mijenja vašu kolekciju fotografija."</string>
    <string name="permlab_mediaLocation" msgid="8675148183726247864">"čitanje lokacija iz kolekcije medija"</string>
    <string name="permdesc_mediaLocation" msgid="2237023389178865130">"Omogućava aplikaciji da čita lokacije iz vaše kolekcije medija."</string>
    <string name="biometric_dialog_default_title" msgid="881952973720613213">"Potvrdite identitet"</string>
    <string name="biometric_error_hw_unavailable" msgid="645781226537551036">"Biometrijski hardver nije dostupan"</string>
    <string name="biometric_error_user_canceled" msgid="2260175018114348727">"Autentifikacija je otkazana"</string>
    <string name="biometric_not_recognized" msgid="5770511773560736082">"Nije prepoznato"</string>
    <string name="biometric_error_canceled" msgid="349665227864885880">"Autentifikacija je otkazana"</string>
    <string name="biometric_error_device_not_secured" msgid="6583143098363528349">"Nije postavljen PIN, uzorak niti lozinka"</string>
    <string name="fingerprint_acquired_partial" msgid="735082772341716043">"Otkriven je djelomičan otisak prsta. Pokušajte ponovo."</string>
    <string name="fingerprint_acquired_insufficient" msgid="4596546021310923214">"Obrada otiska prsta nije uspjela. Pokušajte ponovo."</string>
    <string name="fingerprint_acquired_imager_dirty" msgid="1087209702421076105">"Senzor za otisak prsta je prljav. Očistite ga i pokušajte ponovo."</string>
    <string name="fingerprint_acquired_too_fast" msgid="6470642383109155969">"Prst je uklonjen prebrzo. Pokušajte ponovo."</string>
    <string name="fingerprint_acquired_too_slow" msgid="59250885689661653">"Prst je uklonjen presporo. Pokušajte ponovo."</string>
  <string-array name="fingerprint_acquired_vendor">
  </string-array>
    <string name="fingerprint_authenticated" msgid="5309333983002526448">"Otisak prsta je potvrđen"</string>
    <string name="face_authenticated_no_confirmation_required" msgid="4018680978348659031">"Lice je provjereno"</string>
    <string name="face_authenticated_confirmation_required" msgid="8778347003507633610">"Lice je provjereno, pritisnite dugme za potvrdu"</string>
    <string name="fingerprint_error_hw_not_available" msgid="7955921658939936596">"Hardver za otisak prsta nije dostupan."</string>
    <string name="fingerprint_error_no_space" msgid="1055819001126053318">"Otisak prsta se ne može pohraniti. Uklonite postojeći otisak prsta."</string>
    <string name="fingerprint_error_timeout" msgid="3927186043737732875">"Vrijeme za prepoznavanje otiska prsta je isteklo. Pokušajte ponovo."</string>
    <string name="fingerprint_error_canceled" msgid="4402024612660774395">"Radnja sa otiskom prsta je otkazana."</string>
    <string name="fingerprint_error_user_canceled" msgid="7999639584615291494">"Korisnik je otkazao radnju s otiskom prsta."</string>
    <string name="fingerprint_error_lockout" msgid="5536934748136933450">"Previše pokušaja. Pokušajte ponovo kasnije."</string>
    <string name="fingerprint_error_lockout_permanent" msgid="5033251797919508137">"Previše pokušaja. Senzor za otisak prsta je onemogućen."</string>
    <string name="fingerprint_error_unable_to_process" msgid="6107816084103552441">"Pokušajte ponovo."</string>
    <string name="fingerprint_error_no_fingerprints" msgid="7654382120628334248">"Nije prijavljen nijedan otisak prsta."</string>
    <string name="fingerprint_error_hw_not_present" msgid="409523969613176352">"Ovaj uređaj nema senzor za otisak prsta."</string>
    <string name="fingerprint_name_template" msgid="5870957565512716938">"Prst <xliff:g id="FINGERID">%d</xliff:g>"</string>
  <string-array name="fingerprint_error_vendor">
  </string-array>
    <string name="fingerprint_icon_content_description" msgid="2340202869968465936">"Ikona za otisak prsta"</string>
    <string name="permlab_manageFace" msgid="2137540986007309781">"upravljanje hardverom za autentifikaciju licem"</string>
    <string name="permdesc_manageFace" msgid="8919637120670185330">"Omogućava aplikaciji korištenje metoda za dodavanje i brisanje šablona lica za upotrebu."</string>
    <string name="permlab_useFaceAuthentication" msgid="8996134460546804535">"upotreba hardvera za autentifikaciju licem"</string>
    <string name="permdesc_useFaceAuthentication" msgid="5011118722951833089">"Omogućava aplikaciji da za autentifikaciju koristi hardver za autentifikaciju licem"</string>
    <string name="face_recalibrate_notification_name" msgid="3976629945250435054">"Autentifikacija licem"</string>
    <string name="face_recalibrate_notification_title" msgid="4087620069451499365">"Ponovo registrirajte lice"</string>
    <string name="face_recalibrate_notification_content" msgid="5530308842361499835">"Ponovo registrirajte lice da poboljšate prepoznavanje"</string>
    <string name="face_acquired_insufficient" msgid="2767330364802375742">"Lice nije snimljeno precizno. Pokušajte ponovo."</string>
    <string name="face_acquired_too_bright" msgid="5005650874582450967">"Previše svijetlo. Probajte s blažim osvjetljenjem."</string>
    <string name="face_acquired_too_dark" msgid="1966194696381394616">"Previše je tamno. Pokušajte s jačim osvjetljenjem."</string>
    <string name="face_acquired_too_close" msgid="1401011882624272753">"Odmaknite telefon."</string>
    <string name="face_acquired_too_far" msgid="1210969240069012510">"Primaknite telefon."</string>
    <string name="face_acquired_too_high" msgid="3362395713403348013">"Podignite telefon."</string>
    <string name="face_acquired_too_low" msgid="488983581737550912">"Spustite telefon."</string>
    <string name="face_acquired_too_right" msgid="3667075962661863218">"Pomjerite telefon ulijevo."</string>
    <string name="face_acquired_too_left" msgid="3148242963894703424">"Pomjerite telefon udesno."</string>
    <string name="face_acquired_poor_gaze" msgid="5606479370806754905">"Gledajte direktno u uređaj."</string>
    <string name="face_acquired_not_detected" msgid="4885504661626728809">"Ne vidi se lice. Gledajte u telefon."</string>
    <string name="face_acquired_too_much_motion" msgid="3149332171102108851">"Previše pokreta. Držite telefon mirno."</string>
    <string name="face_acquired_recalibrate" msgid="8077949502893707539">"Ponovo registrirajte lice."</string>
    <string name="face_acquired_too_different" msgid="7663983770123789694">"Nije više moguće prepoznati lice. Pokušajte opet."</string>
    <string name="face_acquired_too_similar" msgid="1508776858407646460">"Previše slično, promijenite položaj."</string>
    <string name="face_acquired_pan_too_extreme" msgid="4581629343077288178">"Malo manje zakrenite glavu."</string>
    <string name="face_acquired_tilt_too_extreme" msgid="4019954263012496468">"Malo manje zakrenite glavu."</string>
    <string name="face_acquired_roll_too_extreme" msgid="6312973147689664409">"Malo manje zakrenite glavu."</string>
    <string name="face_acquired_obscured" msgid="5357207702967893283">"Uklonite prepreke koje blokiraju vaše lice."</string>
    <string name="face_acquired_sensor_dirty" msgid="2535761002815565222">"Očistite senzor na gornjem rubu ekrana."</string>
  <string-array name="face_acquired_vendor">
  </string-array>
    <string name="face_error_hw_not_available" msgid="396883585636963908">"Nije moguće potvrditi lice. Hardver nije dostupan."</string>
    <string name="face_error_timeout" msgid="3202585609451248103">"Pokušajte ponovo s autentifikacijom lica."</string>
    <string name="face_error_no_space" msgid="2712120617457553825">"Nije moguće sačuvati nove podatke o licu. Prvo izbrišite stare."</string>
    <string name="face_error_canceled" msgid="2768146728600802422">"Prepoznavanje lica je otkazano"</string>
    <string name="face_error_user_canceled" msgid="9003022830076496163">"Korisnik je otkazao provjeru lica"</string>
    <string name="face_error_lockout" msgid="3407426963155388504">"Previše pokušaja. Pokušajte ponovo kasnije."</string>
    <string name="face_error_lockout_permanent" msgid="3485837851962070925">"Previše pokušaja. Autentifikacija licem je onemogućena."</string>
    <string name="face_error_unable_to_process" msgid="4940944939691171539">"Nije moguće potvrditi lice. Pokušajte ponovo."</string>
    <string name="face_error_not_enrolled" msgid="2600952202843125796">"Niste postavili autentifikaciju pomoću lica"</string>
    <string name="face_error_hw_not_present" msgid="1317845121210260372">"Autentifikacija pomoću lica nije podržana na ovom uređaju"</string>
    <string name="face_name_template" msgid="7004562145809595384">"Lice <xliff:g id="FACEID">%d</xliff:g>"</string>
  <string-array name="face_error_vendor">
  </string-array>
    <string name="face_icon_content_description" msgid="4024817159806482191">"Ikona lica"</string>
    <string name="permlab_readSyncSettings" msgid="6201810008230503052">"čitanje postavki za sinhroniziranje"</string>
    <string name="permdesc_readSyncSettings" msgid="2706745674569678644">"Omogućava aplikaciji čitanje postavki sinhroniziranja za račun. Naprimjer, ovim se može utvrditi da li je aplikacija People sinhronizirana sa računom."</string>
    <string name="permlab_writeSyncSettings" msgid="5408694875793945314">"aktiviranje/deaktiviranje sinhroniziranja"</string>
    <string name="permdesc_writeSyncSettings" msgid="8956262591306369868">"Omogućava aplikaciji izmjenu postavki sinhroniziranja za račun. Naprimjer, ovim se može omogućiti sinhroniziranje aplikacije People sa računom."</string>
    <string name="permlab_readSyncStats" msgid="7396577451360202448">"čitanje statistike sinhroniziranja"</string>
    <string name="permdesc_readSyncStats" msgid="1510143761757606156">"Omogućava aplikaciji čitanje statistike sinhroniziranja za račun, uključujući historiju događaja sinhroniziranja i količinu sinhroniziranih podataka."</string>
    <string name="permlab_sdcardRead" msgid="1438933556581438863">"čita sadržaj vaše dijeljene pohrane"</string>
    <string name="permdesc_sdcardRead" msgid="1804941689051236391">"Omogućava aplikaciji čitanje sadržaja vaše dijeljenje pohrane."</string>
    <string name="permlab_sdcardWrite" msgid="9220937740184960897">"mijenja ili briše sadržaj vaše dijeljene pohrane"</string>
    <string name="permdesc_sdcardWrite" msgid="2834431057338203959">"Omogućava aplikaciji da piše sadržaj vaše dijeljene pohrane."</string>
    <string name="permlab_use_sip" msgid="2052499390128979920">"Uputi/primi SIP pozive"</string>
    <string name="permdesc_use_sip" msgid="2297804849860225257">"Dozvoljava aplikaciji upućivanje i prijem SIP poziva."</string>
    <string name="permlab_register_sim_subscription" msgid="3166535485877549177">"registriraj nove telekom SMS veze"</string>
    <string name="permdesc_register_sim_subscription" msgid="2138909035926222911">"Dozvoljava aplikaciji da registrira nove telekom SIM veze."</string>
    <string name="permlab_register_call_provider" msgid="108102120289029841">"registriraj nove telekom veze"</string>
    <string name="permdesc_register_call_provider" msgid="7034310263521081388">"Dozvoljava aplikaciji da registrira nove telekom veze."</string>
    <string name="permlab_connection_manager" msgid="1116193254522105375">"upravljaj telekom vezama"</string>
    <string name="permdesc_connection_manager" msgid="5925480810356483565">"Dozvoljava aplikacijama upravljanje telekom vezama."</string>
    <string name="permlab_bind_incall_service" msgid="6773648341975287125">"vrši interakciju s ekranom tokom poziva"</string>
    <string name="permdesc_bind_incall_service" msgid="8343471381323215005">"Dozvoljava aplikaciji da kontrolira kada i kako korisnik vidi ekran tokom poziva."</string>
    <string name="permlab_bind_connection_service" msgid="3557341439297014940">"vrši interakciju s telefonskim uslugama"</string>
    <string name="permdesc_bind_connection_service" msgid="4008754499822478114">"Dozvoljava aplikaciji interakciju s telefonskim uslugama za upućivanje/prijem poziva."</string>
    <string name="permlab_control_incall_experience" msgid="9061024437607777619">"omogući opcije tokom poziva"</string>
    <string name="permdesc_control_incall_experience" msgid="915159066039828124">"Dozvoljava aplikaciji da omogući opcije tokom poziva."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="7862593283611493232">"čitanje historije korištenja mreže"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="7689060749819126472">"Dozvoljava aplikaciji da pročita istoriju korištenja 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">"Dozvoljava aplikaciji upravljanje mrežnim pravilima i određivanje pravila koja se odnose na aplikacije."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="5088217309088729650">"izmjena obračunavanja korištenja mreže"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5443412866746198123">"Dozvoljava aplikaciji izmjenu načina na koji aplikacije koriste mreže. Nije namijenjeno za uobičajene aplikacije."</string>
    <string name="permlab_accessNotifications" msgid="7673416487873432268">"pristup obavještenjima"</string>
    <string name="permdesc_accessNotifications" msgid="458457742683431387">"Omogućava aplikaciji preuzimanje, ispitivanje i brisanje obavještenja, uključujući i ona koja su objavile druge aplikacije."</string>
    <string name="permlab_bindNotificationListenerService" msgid="7057764742211656654">"povezivanje sa uslugom za slušanje obavještenja"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="985697918576902986">"Omogućava vlasniku povezivanje s interfejsom najvišeg nivoa u servisu za slušanje obavještenja. Nije potrebno za obične aplikacije."</string>
    <string name="permlab_bindConditionProviderService" msgid="1180107672332704641">"poveži sa servisom pružaoca uslova"</string>
    <string name="permdesc_bindConditionProviderService" msgid="1680513931165058425">"Dozvoljava vlasniku povezivanje s interfejsom najvišeg nivoa u servisu pružaoca uslova. Nije potrebno za obične aplikacije."</string>
    <string name="permlab_bindDreamService" msgid="4153646965978563462">"poveži sa servisom za čuvanje ekrana"</string>
    <string name="permdesc_bindDreamService" msgid="7325825272223347863">"Dozvoljava vlasniku povezivanje s interfejsom najvišeg nivoa u servisu za čuvanje ekrana. Nije potrebno za obične aplikacije."</string>
    <string name="permlab_invokeCarrierSetup" msgid="3699600833975117478">"pokretanje operaterove aplikacije za konfiguraciju"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4159549152529111920">"Omogućava vlasniku pokretanje aplikacije za konfiguraciju koju je obezbijedio operater. Nije potrebno za normalne aplikacije."</string>
    <string name="permlab_accessNetworkConditions" msgid="8206077447838909516">"slušanje informacija o stanju mreže"</string>
    <string name="permdesc_accessNetworkConditions" msgid="6899102075825272211">"Omogućava aplikaciji slušanje informacije o stanju mreže. Nije potrebno za obične aplikacije."</string>
    <string name="permlab_setInputCalibration" msgid="4902620118878467615">"promijeni kalibraciju ulaznog uređaja"</string>
    <string name="permdesc_setInputCalibration" msgid="4527511047549456929">"Dozvoljava aplikaciji kalibriranje parametara dodirnog ekrana. Nije potrebno za obične aplikacije."</string>
    <string name="permlab_accessDrmCertificates" msgid="7436886640723203615">"pristupi DRM certifikatima"</string>
    <string name="permdesc_accessDrmCertificates" msgid="8073288354426159089">"Dozvoljava aplikaciji da obezbijedi i koristi DRM certifikate. Nije potrebno za obične aplikacije."</string>
    <string name="permlab_handoverStatus" msgid="7820353257219300883">"prijem statusa prebacivanja preko Android prebacivanja"</string>
    <string name="permdesc_handoverStatus" msgid="4788144087245714948">"Dozvoljava aplikaciji prijem informacija o trenutnim prijenosima putem funkcije Android Beam"</string>
    <string name="permlab_removeDrmCertificates" msgid="7044888287209892751">"ukloni DRM certifikate"</string>
    <string name="permdesc_removeDrmCertificates" msgid="7272999075113400993">"Dozvoljava aplikaciji da ukloni DRM certifikate. Nije potrebno za obične aplikacije."</string>
    <string name="permlab_bindCarrierMessagingService" msgid="1490229371796969158">"poveži sa servisom za poruke operatera"</string>
    <string name="permdesc_bindCarrierMessagingService" msgid="2762882888502113944">"Dozvoljava vlasniku povezivanje s interfejsom najvišeg nivoa u servisu za poruke operatera. Nije potrebno za obične aplikacije."</string>
    <string name="permlab_bindCarrierServices" msgid="3233108656245526783">"povezivanje na usluge operatera"</string>
    <string name="permdesc_bindCarrierServices" msgid="1391552602551084192">"Omogućava vlasniku povezivanje sa uslugama operatera. Obično nije potrebno za obične aplikacije."</string>
    <string name="permlab_access_notification_policy" msgid="4247510821662059671">"pristup načinu rada Ne ometaj"</string>
    <string name="permdesc_access_notification_policy" msgid="3296832375218749580">"Omogućava aplikaciji da čita i upisuje konfiguraciju načina rada Ne ometaj."</string>
    <string name="permlab_startViewPermissionUsage" msgid="5484728591597709944">"pokrenuti korištenje odobrenja za pregled"</string>
    <string name="permdesc_startViewPermissionUsage" msgid="4808345878203594428">"Dozvoljava vlasniku da pokrene korištenje odobrenja za aplikaciju. Ne bi trebalo biti potrebno za obične aplikacije."</string>
    <string name="policylab_limitPassword" msgid="4497420728857585791">"Postavljanje pravila za lozinke"</string>
    <string name="policydesc_limitPassword" msgid="2502021457917874968">"Kontrolira dužinu i znakove koji su dozvoljeni u lozinkama za zaključavanje ekrana i PIN-ovima."</string>
    <string name="policylab_watchLogin" msgid="5091404125971980158">"Prati pokušaje otključavanja ekrana"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="3215729294215070072">"Prati broj pogrešno unijetih lozinki prilikom otključavanja ekrana i zaključava tablet ili briše sve podatke s njega ukoliko se previše puta unese pogrešna lozinka."</string>
    <string name="policydesc_watchLogin" product="TV" msgid="2707817988309890256">"Prati koliko puta je lozinka neispravno otkucana prilikom otključavanja ekrana i zaključaj TV ili izbriši sve podatke s TV-a ako se lozinka neispravno ukuca previše puta."</string>
    <string name="policydesc_watchLogin" product="default" msgid="5712323091846761073">"Prati broj pogrešno unesenih lozinki prilikom otključavanja ekrana i zaključava telefon ili briše sve podatke s telefona ukoliko se previše puta unese pogrešna lozinka."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="tablet" msgid="4280246270601044505">"Prati broj neispravnih lozinki koje su unijete za otključavanje ekrana te zaključava tablet ili briše sve podatke ovog korisnika ukoliko je unijeto previše neispravnih lozinki."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="TV" msgid="3484832653564483250">"Prati broj neispravnih lozinki koje su unijete za otključavanje ekrana te zaključava TV ili briše sve podatke ovog korisnika ukoliko je unijeto previše neispravnih lozinki."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="default" msgid="2185480427217127147">"Prati broj neispravnih lozinki koje su unijete za otključavanje ekrana te zaključava telefon ili briše sve podatke ovog korisnika ukoliko je unijeto previše neispravnih lozinki."</string>
    <string name="policylab_resetPassword" msgid="4934707632423915395">"Promijeni zaključavanje ekrana"</string>
    <string name="policydesc_resetPassword" msgid="1278323891710619128">"Mijenja zaključavanje ekrana."</string>
    <string name="policylab_forceLock" msgid="2274085384704248431">"Zaključava ekran"</string>
    <string name="policydesc_forceLock" msgid="1141797588403827138">"Kontrolira kako i kada se ekran zaključava."</string>
    <string name="policylab_wipeData" msgid="3910545446758639713">"Briše sve podatke"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="4306184096067756876">"Briše podatke s tableta bez upozorenja tako što ga vraća na fabričke postavke."</string>
    <string name="policydesc_wipeData" product="tv" msgid="5816221315214527028">"Bez upozorenja obriši sve podatke s TV-a vraćanjem na fabričke postavke."</string>
    <string name="policydesc_wipeData" product="default" msgid="5096895604574188391">"Briše podatke s telefona bez upozorenja vraćanjem telefona na fabričke postavke."</string>
    <string name="policylab_wipeData_secondaryUser" msgid="8362863289455531813">"Izbriši podatke korisnika"</string>
    <string name="policydesc_wipeData_secondaryUser" product="tablet" msgid="6336255514635308054">"Bez upozorenja briše podatke ovog korisnika sa ovog tableta."</string>
    <string name="policydesc_wipeData_secondaryUser" product="tv" msgid="2086473496848351810">"Bez upozorenja briše podatke ovog korisnika sa ovog TV-a."</string>
    <string name="policydesc_wipeData_secondaryUser" product="default" msgid="6787904546711590238">"Bez upozorenja briše podatke ovog korisnika sa ovog telefona."</string>
    <string name="policylab_setGlobalProxy" msgid="2784828293747791446">"Postavlja globalni proksi uređaja"</string>
    <string name="policydesc_setGlobalProxy" msgid="8459859731153370499">"Postavlja globalni proksi uređaja koji će se koristiti dok su smjernice omogućene. Samo vlasnik uređaja može postaviti globalni proksi."</string>
    <string name="policylab_expirePassword" msgid="5610055012328825874">"Postavi isteknuće lozinke za zaključavanje ekrana"</string>
    <string name="policydesc_expirePassword" msgid="5367525762204416046">"Mijenja koliko često se lozinka za zaključavanje ekrana, PIN ili obrazac moraju promijeniti."</string>
    <string name="policylab_encryptedStorage" msgid="8901326199909132915">"Podešava šifriranje pohrane"</string>
    <string name="policydesc_encryptedStorage" msgid="2637732115325316992">"Zahtijeva šifriranje pohranjenih podataka aplikacije."</string>
    <string name="policylab_disableCamera" msgid="6395301023152297826">"Isključuje kamere"</string>
    <string name="policydesc_disableCamera" msgid="2306349042834754597">"Sprečava korištenje svih kamera uređaja."</string>
    <string name="policylab_disableKeyguardFeatures" msgid="8552277871075367771">"Onemog. neke funk. zak. ekrana"</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="2044755691354158439">"Spriječava korištenje nekih funkcija za zaključavanje ekrana."</string>
  <string-array name="phoneTypes">
    <item msgid="8901098336658710359">"Kuća"</item>
    <item msgid="869923650527136615">"Mobilni"</item>
    <item msgid="7897544654242874543">"Posao"</item>
    <item msgid="1103601433382158155">"Poslovni faks"</item>
    <item msgid="1735177144948329370">"Kućni faks"</item>
    <item msgid="603878674477207394">"Pejdžer"</item>
    <item msgid="1650824275177931637">"Ostalo"</item>
    <item msgid="9192514806975898961">"Prilagođeno"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="8073994352956129127">"Kućni"</item>
    <item msgid="7084237356602625604">"Posao"</item>
    <item msgid="1112044410659011023">"Ostalo"</item>
    <item msgid="2374913952870110618">"Prilagođeno"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="6880257626740047286">"Kuća"</item>
    <item msgid="5629153956045109251">"Posao"</item>
    <item msgid="4966604264500343469">"Ostalo"</item>
    <item msgid="4932682847595299369">"Prilagođeno"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="1738585194601476694">"Kućni"</item>
    <item msgid="1359644565647383708">"Posao"</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">"Kuća"</string>
    <string name="phoneTypeMobile" msgid="6501463557754751037">"Mobilni"</string>
    <string name="phoneTypeWork" msgid="8863939667059911633">"Posao"</string>
    <string name="phoneTypeFaxWork" msgid="3517792160008890912">"Poslovni faks"</string>
    <string name="phoneTypeFaxHome" msgid="2067265972322971467">"Kućni faks"</string>
    <string name="phoneTypePager" msgid="7582359955394921732">"Pejdžer"</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">"Poslovni glavni"</string>
    <string name="phoneTypeIsdn" msgid="8022453193171370337">"ISDN"</string>
    <string name="phoneTypeMain" msgid="6766137010628326916">"Glavni"</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">"Poslovni mobilni"</string>
    <string name="phoneTypeWorkPager" msgid="649938731231157056">"Poslovni pejdžer"</string>
    <string name="phoneTypeAssistant" msgid="5596772636128562884">"Asistent"</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">"Ostalo"</string>
    <string name="emailTypeCustom" msgid="8525960257804213846">"Prilagođeno"</string>
    <string name="emailTypeHome" msgid="449227236140433919">"Privatna"</string>
    <string name="emailTypeWork" msgid="3548058059601149973">"Posao"</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">"Kućna adresa"</string>
    <string name="postalTypeWork" msgid="5268172772387694495">"Posao"</string>
    <string name="postalTypeOther" msgid="2726111966623584341">"Ostalo"</string>
    <string name="imTypeCustom" msgid="2074028755527826046">"Prilagođeno"</string>
    <string name="imTypeHome" msgid="6241181032954263892">"Kuća"</string>
    <string name="imTypeWork" msgid="1371489290242433090">"Posao"</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">"Asistent"</string>
    <string name="relationTypeBrother" msgid="8757913506784067713">"Brat"</string>
    <string name="relationTypeChild" msgid="1890746277276881626">"Dijete"</string>
    <string name="relationTypeDomesticPartner" msgid="6904807112121122133">"Nevjenčani partner"</string>
    <string name="relationTypeFather" msgid="5228034687082050725">"Otac"</string>
    <string name="relationTypeFriend" msgid="7313106762483391262">"Prijatelj"</string>
    <string name="relationTypeManager" msgid="6365677861610137895">"Šef"</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">"Uputio(la)"</string>
    <string name="relationTypeRelative" msgid="1799819930085610271">"Rođak/ica"</string>
    <string name="relationTypeSister" msgid="1735983554479076481">"Sestra"</string>
    <string name="relationTypeSpouse" msgid="394136939428698117">"Suprug/a"</string>
    <string name="sipAddressTypeCustom" msgid="2473580593111590945">"Prilagođeno"</string>
    <string name="sipAddressTypeHome" msgid="6093598181069359295">"Kuća"</string>
    <string name="sipAddressTypeWork" msgid="6920725730797099047">"Posao"</string>
    <string name="sipAddressTypeOther" msgid="4408436162950119849">"Ostalo"</string>
    <string name="quick_contacts_not_available" msgid="746098007828579688">"Nije pronađena aplikacija za pregled ovog kontakta."</string>
    <string name="keyguard_password_enter_pin_code" msgid="3037685796058495017">"Unesite PIN"</string>
    <string name="keyguard_password_enter_puk_code" msgid="4800725266925845333">"Unesite PUK i novi PIN"</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="1341112146710087048">"PUK"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="8027680321614196258">"Novi PIN"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="2644215452200037944"><font size="17">"Dodirnite za unos lozinke"</font></string>
    <string name="keyguard_password_enter_password_code" msgid="1054721668279049780">"Unesite lozinku za otključavanje tipkovnice"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="6391755146112503443">"Unesite PIN za otključavanje tipkovnice"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="2422225591006134936">"Pogrešan PIN."</string>
    <string name="keyguard_label_text" msgid="861796461028298424">"Za otključavanje telefona pritisnite dugme Meni, pa dugme 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="696192103195090970">"Broj za hitne slučajeve"</string>
    <string name="lockscreen_carrier_default" msgid="6169005837238288522">"Nema mreže"</string>
    <string name="lockscreen_screen_locked" msgid="7288443074806832904">"Ekran zaključan."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="46154051614126049">"Pritisnite dugme Meni kako biste otključali uređaj ili obavili hitni poziv."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="686260028797158364">"Pritisnite dugme Meni za otključavanje uređaja."</string>
    <string name="lockscreen_pattern_instructions" msgid="7478703254964810302">"Nacrtajte uzorak za otključavanje"</string>
    <string name="lockscreen_emergency_call" msgid="5298642613417801888">"Hitno"</string>
    <string name="lockscreen_return_to_call" msgid="5244259785500040021">"Povratak na 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="lockscreen_storage_locked" msgid="9167551160010625200">"Otključajte uređaj za sve funkcije i podatke"</string>
    <string name="faceunlock_multiple_failures" msgid="754137583022792429">"Premašen maksimalni broj pokušaja otključavanja licem"</string>
    <string name="lockscreen_missing_sim_message_short" msgid="5099439277819215399">"Nema SIM kartice"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="151659196095791474">"Nema SIM kartice u tabletu."</string>
    <string name="lockscreen_missing_sim_message" product="tv" msgid="1943633865476989599">"Nema SIM kartice u TV-u."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="2186920585695169078">"Nema SIM kartice u telefonu."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="5372787138023272615">"Umetnite SIM karticu."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3526573099019319472">"SIM kartica nije umetnuta ili je uređaj ne može očitati. 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 je trajno onemogućena.\nKako biste dobili drugu SIM karticu, obratite se svom pružaocu bežičnih usluga."</string>
    <string name="lockscreen_transport_prev_description" msgid="6300840251218161534">"Prethodna numera"</string>
    <string name="lockscreen_transport_next_description" msgid="573285210424377338">"Sljedeća numera"</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">"Premotaj"</string>
    <string name="lockscreen_transport_ffw_description" msgid="42987149870928985">"Ubrzaj"</string>
    <string name="emergency_calls_only" msgid="6733978304386365407">"Samo hitni pozivi"</string>
    <string name="lockscreen_network_locked_message" msgid="143389224986028501">"Mreža 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 Priručnik za korištenje ili kontaktirajte odjel za brigu o kupcima."</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">"Pogrešno ste nacrtali svoj uzorak za otključavanje <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. \n\nBroj sekundi do sljedećeg pokušaja: <xliff:g id="NUMBER_1">%2$d</xliff:g>"</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="2725973286239344555">"Pogrešno ste unijeli svoju lozinku <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. \n\nBroj sekundi do sljedećeg pokušaja: <xliff:g id="NUMBER_1">%2$d</xliff:g>"</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="6216672706545696955">"Pogrešno ste unijeli svoj PIN <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. \n\nBroj sekundi do sljedećeg pokušaja: <xliff:g id="NUMBER_1">%2$d</xliff:g>"</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="9191611984625460820">"Pogrešno ste unijeli uzorak za otključavanje <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. Možete pokušati još <xliff:g id="NUMBER_1">%2$d</xliff:g> puta. Nakon toga ćete morati otključati tablet prijavom na svoj Google račun.\n\n Broj sekundi do sljedećeg pokušaja: <xliff:g id="NUMBER_2">%3$d</xliff:g>"</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tv" msgid="5316664559603394684">"Uzorak za otključavanje ste neispravno nacrtali <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. U slučaju još <xliff:g id="NUMBER_1">%2$d</xliff:g> pokušaja bez uspjeha, bit će zatraženo da TV otključate pomoću Google prijave.\n\n Pokušajte opet za <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="2590227559763762751">"Pogrešno ste unijeli uzorak za otključavanje <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. Možete pokušati još <xliff:g id="NUMBER_1">%2$d</xliff:g> puta. Nakon toga ćete morati otključati telefon prijavom na svoj Google račun.\n\n Broj sekundi do sljedećeg pokušaja: <xliff:g id="NUMBER_2">%3$d</xliff:g>"</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="6128106399745755604">"Pogrešno ste pokušali otključati tablet <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. Možete pokušati još <xliff:g id="NUMBER_1">%2$d</xliff:g> puta. Ukoliko ni tada ne uspijete otključati tablet, tablet će se vratiti na fabričke postavke i svi korisnički podaci bit će izgubljeni."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tv" msgid="950408382418270260">"Pokušali ste <xliff:g id="NUMBER_0">%1$d</xliff:g> puta neispravno otključati TV. U slučaju još <xliff:g id="NUMBER_1">%2$d</xliff:g> pokušaja bez uspjeha, TV će biti vraćen na fabričke postavke i svi podaci korisnika bit će izgubljeni."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="8603565142156826565">"Pogrešno ste pokušali otključati telefon <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. Možete pokušati još <xliff:g id="NUMBER_1">%2$d</xliff:g> puta. Ukoliko ni tada ne uspijete otključati telefon, telefon će se vratiti na fabričke postavke i svi korisnički podaci bit će izgubljeni."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="280873516493934365">"Pogrešno ste pokušali otključati tablet <xliff:g id="NUMBER">%d</xliff:g> puta. Tablet će sada biti vraćen na fabričke postavke."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tv" msgid="3195755534096192191">"Pokušali ste <xliff:g id="NUMBER">%d</xliff:g> puta neispravno otključati TV. TV će sada biti vraćen na fabričke postavke."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="3025504721764922246">"Pogrešno ste pokušali otključati telefon <xliff:g id="NUMBER">%d</xliff:g> puta. Telefon će sada biti vraćen na fabričke postavke."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6251480343394389665">"Broj sekundi do sljedećeg pokušaja: <xliff:g id="NUMBER">%d</xliff:g>"</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="2626999449610695930">"Zaboravili ste uzorak?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="2588521501166032747">"Otključavanje pomoću Google računa"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="2751368605287288808">"Previše puta ste pokušali otključati uređaj unosom uzorka"</string>
    <string name="lockscreen_glogin_instructions" msgid="3931816256100707784">"Kako biste otključali telefon, prijavite se na svoj Google račun."</string>
    <string name="lockscreen_glogin_username_hint" msgid="8846881424106484447">"Korisničko ime (e-mail)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="5958028383954738528">"Lozinka"</string>
    <string name="lockscreen_glogin_submit_button" msgid="7130893694795786300">"Prijava"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="1364051473347485908">"Pogrešno korisničko ime ili lozinka."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1696924763690379073">"Zaboravili ste korisničko ime ili lozinku?\nPosjetite "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="lockscreen_glogin_checking_password" msgid="7114627351286933867">"Provjera u toku..."</string>
    <string name="lockscreen_unlock_label" msgid="737440483220667054">"Otključaj"</string>
    <string name="lockscreen_sound_on_label" msgid="9068877576513425970">"Zvuk uključen"</string>
    <string name="lockscreen_sound_off_label" msgid="996822825154319026">"Isključi zvuk"</string>
    <string name="lockscreen_access_pattern_start" msgid="3941045502933142847">"Uzorak započet"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="5583479721001639579">"Uzorak izbrisan"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6756031208359292487">"Ćelija dodana"</string>
    <string name="lockscreen_access_pattern_cell_added_verbose" msgid="7264580781744026939">"Ćelija <xliff:g id="CELL_INDEX">%1$s</xliff:g> je dodana"</string>
    <string name="lockscreen_access_pattern_detected" msgid="4988730895554057058">"Uzorak unesen"</string>
    <string name="lockscreen_access_pattern_area" msgid="400813207572953209">"Oblast za unošenje obrasca."</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">"Dodaj widget."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="1281505703307930757">"Prazno"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="2278106022311170299">"Oblast za otključavanje je proširena."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="6366992066936076396">"Oblast za otključavanje je smanjena."</string>
    <string name="keyguard_accessibility_widget" msgid="6527131039741808240">"Widget za <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1226798370913698896">"Biranje korisnika"</string>
    <string name="keyguard_accessibility_status" msgid="8008264603935930611">"Status"</string>
    <string name="keyguard_accessibility_camera" msgid="8904231194181114603">"Kamera"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="262209654292161806">"Upravljanje medijima"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="8736853615588828197">"Promjena rasporeda widgeta je počela."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="7170190950870468320">"Promjena rasporeda widgeta je završena."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="4426204263929224434">"Widget <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> je izbrisan."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="519859720934178024">"Proširi oblast za otključavanje."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2959928478764697254">"Otključavanje pomoću klizača."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="1490840706075246612">"Otključavanje uzorkom."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="4817282543351718535">"Otključavanje licem."</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="2469687111784035046">"Otključavanje pinom."</string>
    <string name="keyguard_accessibility_sim_pin_unlock" msgid="9149698847116962307">"Otključavanje Pin-om za Sim."</string>
    <string name="keyguard_accessibility_sim_puk_unlock" msgid="9106899279724723341">"Otključavanje Puk-om za Sim."</string>
    <string name="keyguard_accessibility_password_unlock" msgid="7675777623912155089">"Otključavanje lozinkom."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="7679891324509597904">"Uzorak oblasti."</string>
    <string name="keyguard_accessibility_slide_area" msgid="6736064494019979544">"Oblast za pomjeranje klizača."</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">"link"</string>
    <string name="granularity_label_line" msgid="5764267235026120888">"linija"</string>
    <string name="factorytest_failed" msgid="5410270329114212041">"Fabrički test nije uspio"</string>
    <string name="factorytest_not_system" msgid="4435201656767276723">"Akcija FACTORY_TEST podržana je samo za pakete instalirane u facsikli /system/app."</string>
    <string name="factorytest_no_action" msgid="872991874799998561">"Nije pronađen paket koji omogućava akciju FACTORY_TEST."</string>
    <string name="factorytest_reboot" msgid="6320168203050791643">"Ponovno pokretanje"</string>
    <string name="js_dialog_title" msgid="1987483977834603872">"Stranica na \"<xliff:g id="TITLE">%s</xliff:g>\" kaže:"</string>
    <string name="js_dialog_title_default" msgid="6961903213729667573">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="2619376555525116593">"Potvrdite navigaciju"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="3112752010600484130">"Napusti ovu 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\n Da li ste sigurni da želite napustiti ovu stranicu?"</string>
    <string name="save_password_label" msgid="6860261758665825069">"Potvrdite"</string>
    <string name="double_tap_toast" msgid="4595046515400268881">"Savjet: Dodirnite ekran dva puta za uvećanje ili smanjenje prikaza."</string>
    <string name="autofill_this_form" msgid="4616758841157816676">"Autofill"</string>
    <string name="setup_autofill" msgid="7103495070180590814">"Podesite Autofill"</string>
    <string name="autofill_window_title" msgid="4107745526909284887">"Automatsko popunjavanje koje pruža usluga <xliff:g id="SERVICENAME">%1$s</xliff:g>"</string>
    <string name="autofill_address_name_separator" msgid="6350145154779706772">" "</string>
    <string name="autofill_address_summary_name_format" msgid="3268041054899214945">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="7483307893170324129">", "</string>
    <string name="autofill_address_summary_format" msgid="4874459455786827344">"$1$2$3"</string>
    <string name="autofill_province" msgid="2231806553863422300">"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">"Okrug"</string>
    <string name="autofill_island" msgid="4020100875984667025">"Ostrvo"</string>
    <string name="autofill_district" msgid="8400735073392267672">"Distrikt"</string>
    <string name="autofill_department" msgid="5343279462564453309">"Odsjek"</string>
    <string name="autofill_prefecture" msgid="2028499485065800419">"Prefektura"</string>
    <string name="autofill_parish" msgid="8202206105468820057">"Parohija"</string>
    <string name="autofill_area" msgid="3547409050889952423">"Oblast"</string>
    <string name="autofill_emirate" msgid="2893880978835698818">"Emirat"</string>
    <string name="permlab_readHistoryBookmarks" msgid="3775265775405106983">"čitanje internet oznaka i historije"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="8462378226600439658">"Omogućava aplikaciji čitanje historije URL-ova koje je preglednik posjetio, kao i svih  oznaka preglednika. Napomena: ovo odobrenje ne mogu iskoristiti preglednici trećih strana ili druge aplikacije koje imaju mogućnost pregledanja interneta."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="3714785165273314490">"pisanje internet oznaka i historije"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="6825527469145760922">"Omogućava aplikaciji da izmijeni historiju ili oznake preglednika koji su pohranjeni na vašem tabletu. Ovim se aplikaciji može omogućiti da izbriše ili izmijeni podatke preglednika. Napomena: ovo odobrenje ne mogu koristiti preglednici trećih strana ili druge aplikacije koje imaju mogućnost pregledanja interneta."</string>
    <string name="permdesc_writeHistoryBookmarks" product="tv" msgid="7007393823197766548">"Dozvoljava aplikaciji izmjenu historije ili oznaka preglednika pohranjenih na TV-u. Ovim se aplikaciji može omogućiti brisanje ili izmjena podataka preglednika. Napomena: ovo odobrenje ne mogu iskoristiti preglednici trećih strana ili druge aplikacije koje imaju mogućnost pregleda interneta."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="8497389531014185509">"Omogućava aplikaciji da izmijeni historiju ili oznake preglednika koji su pohranjeni na vašem telefonu. Ovim se aplikaciji može omogućiti da izbriše ili izmijeni podatke preglednika. Napomena: ovo odobrenje ne mogu koristiti preglednika trećih strana ili druge aplikacije koje imaju mogućnost pregledanja interneta."</string>
    <string name="permlab_setAlarm" msgid="1379294556362091814">"postavljanje alarma"</string>
    <string name="permdesc_setAlarm" msgid="316392039157473848">"Dozvoljava aplikaciji postavljanje alarma u instaliranom budilniku. Moguće je da neki budilnici neće primijeniti ovu funkciju."</string>
    <string name="permlab_addVoicemail" msgid="5525660026090959044">"dodavanje govorne pošte"</string>
    <string name="permdesc_addVoicemail" msgid="6604508651428252437">"Dozvoljava aplikaciji dodavanje poruka u vašu ulaznu govornu poštu."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="5962224158955273932">"izmjena geolokacijskih odobrenja preglednika"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="1083743234522638747">"Dozvoljava aplikaciji mijenjanje geolokacijskih odobrenja preglednika. Zlonamjerne aplikacije mogu to iskoristiti i dozvoliti slanje informacija o lokaciji proizvoljnim web lokcacijama."</string>
    <string name="save_password_message" msgid="767344687139195790">"Želite li da preglednik zapamti ovu lozinku?"</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 odobrenje za otvaranje ove stranice."</string>
    <string name="text_copied" msgid="4985729524670131385">"Tekst kopiran u međuspremnik."</string>
    <string name="copied" msgid="8564151838171791598">"Kopirano"</string>
    <string name="more_item_label" msgid="4650918923083320495">"Više"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Meni+"</string>
    <string name="menu_meta_shortcut_label" msgid="4647153495550313570">"Meta+"</string>
    <string name="menu_ctrl_shortcut_label" msgid="3917070091228880941">"Ctrl+"</string>
    <string name="menu_alt_shortcut_label" msgid="6249849492641218944">"Alt+"</string>
    <string name="menu_shift_shortcut_label" msgid="6773890288720306380">"Shift+"</string>
    <string name="menu_sym_shortcut_label" msgid="4019695553731017933">"Sym+"</string>
    <string name="menu_function_shortcut_label" msgid="1984053777418162618">"Function+"</string>
    <string name="menu_space_shortcut_label" msgid="2410328639272162537">"razmak"</string>
    <string name="menu_enter_shortcut_label" msgid="2743362785111309668">"potvrdi"</string>
    <string name="menu_delete_shortcut_label" msgid="3658178007202748164">"izbriši"</string>
    <string name="search_go" msgid="8298016669822141719">"Pretraži"</string>
    <string name="search_hint" msgid="1733947260773056054">"Pretražite..."</string>
    <string name="searchview_description_search" msgid="6749826639098512120">"Pretraživanje"</string>
    <string name="searchview_description_query" msgid="5911778593125355124">"Upit za pretragu"</string>
    <string name="searchview_description_clear" msgid="1330281990951833033">"Obriši upit"</string>
    <string name="searchview_description_submit" msgid="2688450133297983542">"Potvrditi upit"</string>
    <string name="searchview_description_voice" msgid="2453203695674994440">"Glasovno pretraživanje"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="7460694070309730149">"Želite li 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 Istraživanje dodirom. Kada je Istraživanje dodirom uključeno, možete čuti ili vidjeti opise onoga što vam je pod prstom ili praviti pokrete za interakciju sa tabletom."</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 Istraživanje dodirom. Kada je Istraživanje dodirom uključeno, možete čuti ili vidjeti opise onoga što vam je pod prstom ili praviti pokrete za interakciju sa telefonom."</string>
    <string name="oneMonthDurationPast" msgid="7396384508953779925">"Prije mjesec dana"</string>
    <string name="beforeOneMonthDurationPast" msgid="909134546836499826">"Prije više od mjesec dana"</string>
    <plurals name="last_num_days" formatted="false" msgid="5104533550723932025">
      <item quantity="one">Prethodni <xliff:g id="COUNT_1">%d</xliff:g> dan</item>
      <item quantity="few">Prethodna <xliff:g id="COUNT_1">%d</xliff:g> dana</item>
      <item quantity="other">Prethodnih <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>
    <string name="preposition_for_date" msgid="9093949757757445117">"<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">"godine <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">"sat"</string>
    <string name="hours" msgid="894424005266852993">"sati"</string>
    <string name="minute" msgid="9148878657703769868">"minuta"</string>
    <string name="minutes" msgid="5646001005827034509">"minute"</string>
    <string name="second" msgid="3184235808021478">"sekunda"</string>
    <string name="seconds" msgid="3161515347216589235">"s"</string>
    <string name="week" msgid="5617961537173061583">"sedmica"</string>
    <string name="weeks" msgid="6509623834583944518">"sedmice"</string>
    <string name="year" msgid="4001118221013892076">"godina"</string>
    <string name="years" msgid="6881577717993213522">"godine"</string>
    <string name="now_string_shortest" msgid="8912796667087856402">"sada"</string>
    <plurals name="duration_minutes_shortest" formatted="false" msgid="3957499975064245495">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> m</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>m</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>m</item>
    </plurals>
    <plurals name="duration_hours_shortest" formatted="false" msgid="3552182110578602356">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>h</item>
    </plurals>
    <plurals name="duration_days_shortest" formatted="false" msgid="5213655532597081640">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> d</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>d</item>
    </plurals>
    <plurals name="duration_years_shortest" formatted="false" msgid="7848711145196397042">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g>g</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g>g</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g>g</item>
    </plurals>
    <plurals name="duration_minutes_shortest_future" formatted="false" msgid="3277614521231489951">
      <item quantity="one">za <xliff:g id="COUNT_1">%d</xliff:g>m</item>
      <item quantity="few">za <xliff:g id="COUNT_1">%d</xliff:g>m</item>
      <item quantity="other">za <xliff:g id="COUNT_1">%d</xliff:g>m</item>
    </plurals>
    <plurals name="duration_hours_shortest_future" formatted="false" msgid="2152452368397489370">
      <item quantity="one">za <xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="few">za <xliff:g id="COUNT_1">%d</xliff:g>h</item>
      <item quantity="other">za <xliff:g id="COUNT_1">%d</xliff:g>h</item>
    </plurals>
    <plurals name="duration_days_shortest_future" formatted="false" msgid="8088331502820295701">
      <item quantity="one">za <xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="few">za <xliff:g id="COUNT_1">%d</xliff:g>d</item>
      <item quantity="other">za <xliff:g id="COUNT_1">%d</xliff:g>d</item>
    </plurals>
    <plurals name="duration_years_shortest_future" formatted="false" msgid="2317006667145250301">
      <item quantity="one">za <xliff:g id="COUNT_1">%d</xliff:g> g</item>
      <item quantity="few">za <xliff:g id="COUNT_1">%d</xliff:g> g</item>
      <item quantity="other">za <xliff:g id="COUNT_1">%d</xliff:g> g</item>
    </plurals>
    <plurals name="duration_minutes_relative" formatted="false" msgid="3178131706192980192">
      <item quantity="one"> Prije <xliff:g id="COUNT_1">%d</xliff:g> minutu</item>
      <item quantity="few"> Prije <xliff:g id="COUNT_1">%d</xliff:g> minute</item>
      <item quantity="other"> Prije <xliff:g id="COUNT_1">%d</xliff:g> minuta</item>
    </plurals>
    <plurals name="duration_hours_relative" formatted="false" msgid="676894109982008411">
      <item quantity="one"> Prije <xliff:g id="COUNT_1">%d</xliff:g> sat</item>
      <item quantity="few"> Prije <xliff:g id="COUNT_1">%d</xliff:g> sata</item>
      <item quantity="other"> Prije <xliff:g id="COUNT_1">%d</xliff:g> sati</item>
    </plurals>
    <plurals name="duration_days_relative" formatted="false" msgid="2203515825765397130">
      <item quantity="one"> Prije <xliff:g id="COUNT_1">%d</xliff:g> dan</item>
      <item quantity="few"> Prije <xliff:g id="COUNT_1">%d</xliff:g> dana</item>
      <item quantity="other"> Prije <xliff:g id="COUNT_1">%d</xliff:g> dana</item>
    </plurals>
    <plurals name="duration_years_relative" formatted="false" msgid="4820062134188885734">
      <item quantity="one"> Prije <xliff:g id="COUNT_1">%d</xliff:g> godinu</item>
      <item quantity="few"> Prije <xliff:g id="COUNT_1">%d</xliff:g> godine</item>
      <item quantity="other"> Prije <xliff:g id="COUNT_1">%d</xliff:g> godina</item>
    </plurals>
    <plurals name="duration_minutes_relative_future" formatted="false" msgid="4655043589817680966">
      <item quantity="one"> za <xliff:g id="COUNT_1">%d</xliff:g> minutu</item>
      <item quantity="few"> za <xliff:g id="COUNT_1">%d</xliff:g> minute</item>
      <item quantity="other"> za <xliff:g id="COUNT_1">%d</xliff:g> minuta</item>
    </plurals>
    <plurals name="duration_hours_relative_future" formatted="false" msgid="8084579714205223891">
      <item quantity="one"> za <xliff:g id="COUNT_1">%d</xliff:g> sat</item>
      <item quantity="few"> za <xliff:g id="COUNT_1">%d</xliff:g> sata</item>
      <item quantity="other"> za <xliff:g id="COUNT_1">%d</xliff:g> sati</item>
    </plurals>
    <plurals name="duration_days_relative_future" formatted="false" msgid="333215369363433992">
      <item quantity="one"> za <xliff:g id="COUNT_1">%d</xliff:g> dan</item>
      <item quantity="few"> za <xliff:g id="COUNT_1">%d</xliff:g> dana</item>
      <item quantity="other"> za <xliff:g id="COUNT_1">%d</xliff:g> dana</item>
    </plurals>
    <plurals name="duration_years_relative_future" formatted="false" msgid="8644862986413104011">
      <item quantity="one"> za <xliff:g id="COUNT_1">%d</xliff:g> godinu</item>
      <item quantity="few"> za <xliff:g id="COUNT_1">%d</xliff:g> godine</item>
      <item quantity="other"> za <xliff:g id="COUNT_1">%d</xliff:g> godina</item>
    </plurals>
    <string name="VideoView_error_title" msgid="3534509135438353077">"Problem sa prikazom video sadržaja"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3186670335938670444">"Prijenos ovog video sadržaja ne može se izvršiti na ovom uređaju."</string>
    <string name="VideoView_error_text_unknown" msgid="3450439155187810085">"Greška prilikom reproduciranja video sadržaja."</string>
    <string name="VideoView_error_button" msgid="2822238215100679592">"Uredu"</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="failed_to_copy_to_clipboard" msgid="1833662432489814471">"Kopiranje u spremnik nije uspjelo"</string>
    <string name="paste" msgid="5629880836805036433">"Zalijepi"</string>
    <string name="paste_as_plain_text" msgid="5427792741908010675">"Zalijepi kao neformatiran tekst"</string>
    <string name="replace" msgid="5781686059063148930">"Zamijeniti..."</string>
    <string name="delete" msgid="6098684844021697789">"Izbrišite"</string>
    <string name="copyUrl" msgid="2538211579596067402">"Kopirajte URL"</string>
    <string name="selectTextMode" msgid="1018691815143165326">"Odaberi tekst"</string>
    <string name="undo" msgid="7905788502491742328">"Vrati"</string>
    <string name="redo" msgid="7759464876566803888">"Ponovo uradi"</string>
    <string name="autofill" msgid="3035779615680565188">"Automatsko popunjavanje"</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">"Akcije za tekst"</string>
    <string name="email" msgid="4560673117055050403">"Pošalji e-poruku"</string>
    <string name="email_desc" msgid="3638665569546416795">"Pošalji e-poruku na odabranu adresu"</string>
    <string name="dial" msgid="1253998302767701559">"Pozovi"</string>
    <string name="dial_desc" msgid="6573723404985517250">"Pozovi odabrani broj telefona"</string>
    <string name="map" msgid="5441053548030107189">"Prikaži na mapi"</string>
    <string name="map_desc" msgid="1836995341943772348">"Lociraj odabranu adresu"</string>
    <string name="browse" msgid="1245903488306147205">"Otvori"</string>
    <string name="browse_desc" msgid="8220976549618935044">"Otvori odabrani URL"</string>
    <string name="sms" msgid="4560537514610063430">"Pošalji SMS"</string>
    <string name="sms_desc" msgid="7526588350969638809">"Pošalji SMS odabranom broju telefona"</string>
    <string name="add_contact" msgid="7867066569670597203">"Dodaj"</string>
    <string name="add_contact_desc" msgid="4830217847004590345">"Dodaj u kontakte"</string>
    <string name="view_calendar" msgid="979609872939597838">"Prikaži"</string>
    <string name="view_calendar_desc" msgid="5828320291870344584">"Prikaži odabrano vrijeme u kalendaru"</string>
    <string name="add_calendar_event" msgid="1953664627192056206">"Zakaži"</string>
    <string name="add_calendar_event_desc" msgid="4326891793260687388">"Zakaži događaj za odabrano vrijeme"</string>
    <string name="view_flight" msgid="7691640491425680214">"Prati"</string>
    <string name="view_flight_desc" msgid="3876322502674253506">"Prati odabrani let"</string>
    <string name="translate" msgid="9218619809342576858">"Prevedi"</string>
    <string name="translate_desc" msgid="4502367770068777202">"Prevedi odabrani tekst"</string>
    <string name="define" msgid="7394820043869954211">"Definiraj"</string>
    <string name="define_desc" msgid="7910883642444919726">"Definiraj odabrani tekst"</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 funkcije sistema možda neće raditi"</string>
    <string name="low_internal_storage_view_text_no_boot" msgid="6935190099204693424">"Nema dovoljno prostora za sistem. Obezbijedite 250MB slobodnog prostora i ponovo pokrenite uređaj."</string>
    <string name="app_running_notification_title" msgid="8718335121060787914">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> je pokrenuta"</string>
    <string name="app_running_notification_text" msgid="1197581823314971177">"Dodirnite za više informacija ili da biste zaustavili aplikaciju."</string>
    <string name="ok" msgid="5970060430562524910">"Uredu"</string>
    <string name="cancel" msgid="6442560571259935130">"Otkaži"</string>
    <string name="yes" msgid="5362982303337969312">"Uredu"</string>
    <string name="no" msgid="5141531044935541497">"Otkaži"</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">"Uključeno"</string>
    <string name="capital_off" msgid="6815870386972805832">"Isključeno"</string>
    <string name="whichApplication" msgid="4533185947064773386">"Izvrši akciju koristeći"</string>
    <string name="whichApplicationNamed" msgid="8260158865936942783">"Dovršite akciju koristeći %1$s"</string>
    <string name="whichApplicationLabel" msgid="7425855495383818784">"Izvršiti akciju"</string>
    <string name="whichViewApplication" msgid="3272778576700572102">"Otvori koristeći"</string>
    <string name="whichViewApplicationNamed" msgid="2286418824011249620">"Otvori koristeći %1$s"</string>
    <string name="whichViewApplicationLabel" msgid="2666774233008808473">"Otvori"</string>
    <string name="whichGiveAccessToApplication" msgid="8279395245414707442">"Dozvolite pristup za otvaranje linkova hosta <xliff:g id="HOST">%1$s</xliff:g> pomoću"</string>
    <string name="whichGiveAccessToApplicationNamed" msgid="7992388824107710849">"Dozvolite pristup za otvaranje linkova hosta <xliff:g id="HOST">%1$s</xliff:g> pomoću aplikacije <xliff:g id="APPLICATION">%2$s</xliff:g>"</string>
    <string name="whichGiveAccessToApplicationLabel" msgid="6142688895536868827">"Dozvoli pristup"</string>
    <string name="whichEditApplication" msgid="144727838241402655">"Uredi koristeći"</string>
    <string name="whichEditApplicationNamed" msgid="1775815530156447790">"Uredi koristeći %1$s"</string>
    <string name="whichEditApplicationLabel" msgid="7183524181625290300">"Uredi"</string>
    <string name="whichSendApplication" msgid="5803792421724377602">"Dijeli"</string>
    <string name="whichSendApplicationNamed" msgid="2799370240005424391">"Dijeli koristeći %1$s"</string>
    <string name="whichSendApplicationLabel" msgid="4579076294675975354">"Dijeli"</string>
    <string name="whichSendToApplication" msgid="8272422260066642057">"Pošalji koristeći"</string>
    <string name="whichSendToApplicationNamed" msgid="7768387871529295325">"Pošalji koristeći %1$s"</string>
    <string name="whichSendToApplicationLabel" msgid="8878962419005813500">"Pošalji"</string>
    <string name="whichHomeApplication" msgid="4307587691506919691">"Odaberi glavnu aplikaciju"</string>
    <string name="whichHomeApplicationNamed" msgid="4493438593214760979">"Koristi %1$s kao glavnu aplikaciju"</string>
    <string name="whichHomeApplicationLabel" msgid="809529747002918649">"Snimanje slike"</string>
    <string name="whichImageCaptureApplication" msgid="3680261417470652882">"Snimanje slike koristeći"</string>
    <!-- String.format failed for translation -->
    <!-- no translation found for whichImageCaptureApplicationNamed (8619384150737825003) -->
    <skip />
    <string name="whichImageCaptureApplicationLabel" msgid="6390303445371527066">"Snimanje slike"</string>
    <string name="alwaysUse" msgid="4583018368000610438">"Koristiti kao zadanu rezoluciju za ovu akciju."</string>
    <string name="use_a_different_app" msgid="8134926230585710243">"Koristi drugu aplikaciju"</string>
    <string name="clearDefaultHintMsg" msgid="3252584689512077257">"Obrišite zadane opcije u meniju Postavke sistema &gt; Aplikacije &gt; Preuzete aplikacije."</string>
    <string name="chooseActivity" msgid="7486876147751803333">"Odaberite akciju"</string>
    <string name="chooseUsbActivity" msgid="6894748416073583509">"Odaberite aplikaciju za USB uređaj"</string>
    <string name="noApplications" msgid="2991814273936504689">"Nijedna aplikacija ne može izvršiti ovu akciju."</string>
    <string name="aerr_application" msgid="250320989337856518">"Aplikacija <xliff:g id="APPLICATION">%1$s</xliff:g> je zaustavljena"</string>
    <string name="aerr_process" msgid="6201597323218674729">"<xliff:g id="PROCESS">%1$s</xliff:g> je zaustavljen"</string>
    <string name="aerr_application_repeated" msgid="3146328699537439573">"<xliff:g id="APPLICATION">%1$s</xliff:g> se stalno zaustavlja"</string>
    <string name="aerr_process_repeated" msgid="6235302956890402259">"<xliff:g id="PROCESS">%1$s</xliff:g> se stalno zaustavlja"</string>
    <string name="aerr_restart" msgid="7581308074153624475">"Ponovo otvori aplikaciju"</string>
    <string name="aerr_report" msgid="5371800241488400617">"Pošalji povratne informacije"</string>
    <string name="aerr_close" msgid="2991640326563991340">"Zatvori"</string>
    <string name="aerr_mute" msgid="1974781923723235953">"Isključiti zvuk dok se uređaj ponovo ne pokrene"</string>
    <string name="aerr_wait" msgid="3199956902437040261">"Sačekaj"</string>
    <string name="aerr_close_app" msgid="3269334853724920302">"Zatvori aplikaciju"</string>
    <string name="anr_title" msgid="4351948481459135709"></string>
    <string name="anr_activity_application" msgid="8493290105678066167">"<xliff:g id="APPLICATION">%2$s</xliff:g> ne reaguje"</string>
    <string name="anr_activity_process" msgid="1622382268908620314">"<xliff:g id="ACTIVITY">%1$s</xliff:g> ne reaguje"</string>
    <string name="anr_application_process" msgid="6417199034861140083">"<xliff:g id="APPLICATION">%1$s</xliff:g> ne reaguje"</string>
    <string name="anr_process" msgid="6156880875555921105">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> ne reaguje"</string>
    <string name="force_close" msgid="8346072094521265605">"Uredu"</string>
    <string name="report" msgid="4060218260984795706">"Prijavi"</string>
    <string name="wait" msgid="7147118217226317732">"Sačekaj"</string>
    <string name="webpage_unresponsive" msgid="3272758351138122503">"Stranica ne reagira.\n\nŽelite li je zatvoriti?"</string>
    <string name="launch_warning_title" msgid="1547997780506713581">"Aplikacija preusmjerena"</string>
    <string name="launch_warning_replace" msgid="6202498949970281412">"Sada je pokrenuta aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="launch_warning_original" msgid="188102023021668683">"Izvorno je pokrenuta aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="screen_compat_mode_scale" msgid="3202955667675944499">"Razmjer"</string>
    <string name="screen_compat_mode_show" msgid="4013878876486655892">"Uvijek prikaži"</string>
    <string name="screen_compat_mode_hint" msgid="1064524084543304459">"Ponovo omogućite ovu opciju u meniju Postavke sistema &gt; Aplikacije &gt; Preuzete aplikacije."</string>
    <string name="unsupported_display_size_message" msgid="6545327290756295232">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> ne podržava trenutnu postavku veličine ekrana i može se ponašati neočekivano."</string>
    <string name="unsupported_display_size_show" msgid="7969129195360353041">"Uvijek prikaži"</string>
    <string name="unsupported_compile_sdk_message" msgid="4253168368781441759">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> je napravljena za verziju operativnog sistema Android koja nije kompatibilna i može se ponašati neočekivano. Ažurirana verzija aplikacije može biti dostupna."</string>
    <string name="unsupported_compile_sdk_show" msgid="2681877855260970231">"Uvijek prikaži"</string>
    <string name="unsupported_compile_sdk_check_update" msgid="3312723623323216101">"Provjeri ima li ažuriranja"</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 vlastita StrictMode pravila."</string>
    <string name="smv_process" msgid="5120397012047462446">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> prekršio je vlastita StrictMode pravila."</string>
    <string name="android_upgrading_title" product="default" msgid="7513829952443484438">"Ažuriranje telefona…"</string>
    <string name="android_upgrading_title" product="tablet" msgid="4503169817302593560">"Ažuriranje tableta…"</string>
    <string name="android_upgrading_title" product="device" msgid="7009520271220804517">"Ažuriranje uređaja…"</string>
    <string name="android_start_title" product="default" msgid="4536778526365907780">"Pokretanje telefona…"</string>
    <string name="android_start_title" product="automotive" msgid="8418054686415318207">"Android se pokreće..."</string>
    <string name="android_start_title" product="tablet" msgid="4929837533850340472">"Pokretanje tableta…"</string>
    <string name="android_start_title" product="device" msgid="7467484093260449437">"Pokretanje uređaja…"</string>
    <string name="android_upgrading_fstrim" msgid="8036718871534640010">"Optimiziranje pohrane."</string>
    <string name="android_upgrading_notification_title" product="default" msgid="1511552415039349062">"Dovršavanje ažuriranja sistema…"</string>
    <string name="app_upgrading_toast" msgid="3008139776215597053">"Aplikacija <xliff:g id="APPLICATION">%1$s</xliff:g> se nadograđuje…"</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_preparing_apk" msgid="8162599310274079154">"Pripremanje aplikacije <xliff:g id="APPNAME">%1$s</xliff:g>."</string>
    <string name="android_upgrading_starting_apps" msgid="451464516346926713">"Pokretanje aplikacija."</string>
    <string name="android_upgrading_complete" msgid="1405954754112999229">"Pokretanje pri kraju."</string>
    <string name="heavy_weight_notification" msgid="9087063985776626166">"Pokrenuta je aplikacija <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="heavy_weight_notification_detail" msgid="2304833848484424985">"Dodirnite za povratak u igru"</string>
    <string name="heavy_weight_switcher_title" msgid="387882830435195342">"Odaberite igru"</string>
    <string name="heavy_weight_switcher_text" msgid="4176781660362912010">"Radi boljih performansi, moguće je otvoriti samo po jednu od ovih igara."</string>
    <string name="old_app_action" msgid="3044685170829526403">"Vrati se nazad u aplikaciju <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_action" msgid="6694851182870774403">"Otvori aplikaciju <xliff:g id="NEW_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="5894852887817332322">"Aplikacija <xliff:g id="OLD_APP">%1$s</xliff:g> će se zatvoriti bez pohranjivanja"</string>
    <string name="dump_heap_notification" msgid="2618183274836056542">"<xliff:g id="PROC">%1$s</xliff:g> premašuje ograničenje memorije"</string>
    <string name="dump_heap_ready_notification" msgid="1162196579925048701">"Snimak dinamičkog dijela memorije procesa <xliff:g id="PROC">%1$s</xliff:g> je spreman"</string>
    <string name="dump_heap_notification_detail" msgid="3993078784053054141">"Snimak dinamičkog dijela memorije je napravljen. Dodirnite za dijeljenje."</string>
    <string name="dump_heap_title" msgid="5864292264307651673">"Želite li dijeliti snimak dinamičkog dijela memorije?"</string>
    <string name="dump_heap_text" msgid="8546022920319781701">"Proces <xliff:g id="PROC">%1$s</xliff:g> je premašio ograničenje memorije od <xliff:g id="SIZE">%2$s</xliff:g>. Snimak dinamičkog dijela memorije vam je dostupan i možete ga dijeliti s njegovim programerom. Budite oprezni: ovaj snimak dinamičkog dijela memorije može sadržavati vaše lične podatke kojima aplikacija ima pristup."</string>
    <string name="dump_heap_system_text" msgid="3236094872980706024">"Proces <xliff:g id="PROC">%1$s</xliff:g> je premašio ograničenje memorije od <xliff:g id="SIZE">%2$s</xliff:g>. Snimak dinamičkog dijela memorije vam je dostupan i možete ga dijeliti. Budite oprezni: ovaj snimak dinamičkog dijela memorije može sadržavati osjetljive lične podatke kojima ovaj proces ima pristup i mogu uključivati stvari koje ste unijeli."</string>
    <string name="dump_heap_ready_text" msgid="1778041771455343067">"Snimak dinamičkog dijela memorije procesa <xliff:g id="PROC">%1$s</xliff:g> dostupan vam je i možete ga dijeliti. Budite oprezni: ovaj snimak dinamičkog dijela memorije može sadržavati osjetljive lične podatke kojima ovaj proces ima pristup i mogu uključivati stvari koje ste unijeli."</string>
    <string name="sendText" msgid="5209874571959469142">"Biranje akcije za tekst"</string>
    <string name="volume_ringtone" msgid="6885421406845734650">"Jačina zvuka zvona"</string>
    <string name="volume_music" msgid="5421651157138628171">"Jačina zvuka medija"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="9165984379394601533">"Medijski sadržaj se reproducira preko Bluetooth veze"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="8310739960973156272">"Postavljena nečujna melodija zvona"</string>
    <string name="volume_call" msgid="3941680041282788711">"Jačina zvuka tokom poziva"</string>
    <string name="volume_bluetooth_call" msgid="2002891926351151534">"Jačina zvuka tokom poziva preko Bluetooth veze"</string>
    <string name="volume_alarm" msgid="1985191616042689100">"Jačina zvuka alarma"</string>
    <string name="volume_notification" msgid="2422265656744276715">"Jačina zvuka za obavještenja"</string>
    <string name="volume_unknown" msgid="1400219669770445902">"Jačina zvuka"</string>
    <string name="volume_icon_description_bluetooth" msgid="6538894177255964340">"Jačina zvuka za Bluetooth vezu"</string>
    <string name="volume_icon_description_ringer" msgid="3326003847006162496">"Jačina zvuka melodije"</string>
    <string name="volume_icon_description_incall" msgid="8890073218154543397">"Jačina zvuka tokom poziva"</string>
    <string name="volume_icon_description_media" msgid="4217311719665194215">"Jačina zvuka medija"</string>
    <string name="volume_icon_description_notification" msgid="7044986546477282274">"Jačina zvuka za obavještenja"</string>
    <string name="ringtone_default" msgid="3789758980357696936">"Zadana melodija zvona"</string>
    <string name="ringtone_default_with_actual" msgid="1767304850491060581">"Zadano (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="7937634392408977062">"Bez zvuka"</string>
    <string name="ringtone_picker_title" msgid="3515143939175119094">"Melodije zvona"</string>
    <string name="ringtone_picker_title_alarm" msgid="6473325356070549702">"Zvukovi alarma"</string>
    <string name="ringtone_picker_title_notification" msgid="4837740874822788802">"Zvukovi obavještenja"</string>
    <string name="ringtone_unknown" msgid="3914515995813061520">"Nepoznato"</string>
    <plurals name="wifi_available" formatted="false" msgid="7900333017752027322">
      <item quantity="one">WiFi mreže su dostupne</item>
      <item quantity="few">WiFi mreže su dostupne</item>
      <item quantity="other">WiFi mreže su dostupne</item>
    </plurals>
    <plurals name="wifi_available_detailed" formatted="false" msgid="1140699367193975606">
      <item quantity="one">Otvorene WiFi mreže su dostupne</item>
      <item quantity="few">Otvorene WiFi mreže su dostupne</item>
      <item quantity="other">Otvorene WiFi mreže su dostupne</item>
    </plurals>
    <string name="wifi_available_title" msgid="3817100557900599505">"Povežite se na otvorenu Wi‑Fi mrežu"</string>
    <string name="wifi_available_carrier_network_title" msgid="4527932626916527897">"Povežite se na Wi‑Fi mrežu mobilnog operatera"</string>
    <string name="wifi_available_title_connecting" msgid="1139126673968899002">"Povezivanje na WiFi mrežu"</string>
    <string name="wifi_available_title_connected" msgid="7542672851522241548">"Povezani ste na Wi‑Fi mrežu"</string>
    <string name="wifi_available_title_failed_to_connect" msgid="6861772233582618132">"Nije se moguće povezati na Wi‑Fi mrežu"</string>
    <string name="wifi_available_content_failed_to_connect" msgid="3377406637062802645">"Dodirnite da vidite sve mreže"</string>
    <string name="wifi_available_action_connect" msgid="2635699628459488788">"Povežite se"</string>
    <string name="wifi_available_action_all_networks" msgid="4368435796357931006">"Sve mreže"</string>
    <string name="wifi_suggestion_title" msgid="9099832833531486167">"Povezivati na WiFi mreže?"</string>
    <string name="wifi_suggestion_content" msgid="5883181205841582873">"Predlaže <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="wifi_suggestion_action_allow_app" msgid="3689946344485394085">"Da"</string>
    <string name="wifi_suggestion_action_disallow_app" msgid="7977918905605931385">"Ne"</string>
    <string name="wifi_wakeup_onboarding_title" msgid="228772560195634292">"WiFi će se uključiti automatski"</string>
    <string name="wifi_wakeup_onboarding_subtext" msgid="3989697580301186973">"Kada ste u blizini sačuvane mreže visokog kvaliteta"</string>
    <string name="wifi_wakeup_onboarding_action_disable" msgid="838648204200836028">"Nemoj ponovo uključiti"</string>
    <string name="wifi_wakeup_enabled_title" msgid="6534603733173085309">"Wi‑Fi veza se automatski uključila"</string>
    <string name="wifi_wakeup_enabled_content" msgid="189330154407990583">"U blizini ste sačuvane mreže: <xliff:g id="NETWORK_SSID">%1$s</xliff:g>"</string>
    <string name="wifi_available_sign_in" msgid="9157196203958866662">"Prijavljivanje na WiFi mrežu"</string>
    <string name="network_available_sign_in" msgid="1848877297365446605">"Prijava na mrežu"</string>
    <!-- no translation found for network_available_sign_in_detailed (8000081941447976118) -->
    <skip />
    <string name="wifi_no_internet" msgid="5198100389964214865">"Mreža <xliff:g id="NETWORK_SSID">%1$s</xliff:g> nema pristup internetu"</string>
    <string name="wifi_no_internet_detailed" msgid="8083079241212301741">"Dodirnite za opcije"</string>
    <string name="captive_portal_logged_in_detailed" msgid="8489345381637456021">"Povezano"</string>
    <string name="network_partial_connectivity" msgid="7774883385494762741">"Mreža <xliff:g id="NETWORK_SSID">%1$s</xliff:g> ima ograničenu povezivost"</string>
    <string name="network_partial_connectivity_detailed" msgid="1959697814165325217">"Dodirnite da se ipak povežete"</string>
    <string name="wifi_softap_config_change" msgid="8475911871165857607">"Promjene postavki vaše pristupne tačke"</string>
    <string name="wifi_softap_config_change_summary" msgid="7601233252456548891">"Opseg vaše pristupne tačke je promijenjen."</string>
    <string name="wifi_softap_config_change_detailed" msgid="8022936822860678033">"Ovaj uređaj ne podržava vašu postavku za mreže od isključivo 5GHz. Uređaj će koristiti opseg of 5GHz kada je dostupan."</string>
    <string name="network_switch_metered" msgid="4671730921726992671">"Prebačeno na: <xliff:g id="NETWORK_TYPE">%1$s</xliff:g>"</string>
    <string name="network_switch_metered_detail" msgid="775163331794506615">"Kada <xliff:g id="PREVIOUS_NETWORK">%2$s</xliff:g> nema pristup internetu, uređaj koristi mrežu <xliff:g id="NEW_NETWORK">%1$s</xliff:g>. Moguća je naplata usluge."</string>
    <string name="network_switch_metered_toast" msgid="5779283181685974304">"Prebačeno iz mreže <xliff:g id="PREVIOUS_NETWORK">%1$s</xliff:g> u <xliff:g id="NEW_NETWORK">%2$s</xliff:g> mrežu"</string>
  <string-array name="network_switch_type_name">
    <item msgid="3979506840912951943">"prijenos podataka na mobilnoj mreži"</item>
    <item msgid="75483255295529161">"WiFi"</item>
    <item msgid="6862614801537202646">"Bluetooth"</item>
    <item msgid="5447331121797802871">"Ethernet"</item>
    <item msgid="8257233890381651999">"VPN"</item>
  </string-array>
    <string name="network_switch_type_name_unknown" msgid="4552612897806660656">"nepoznata vrsta mreže"</string>
    <string name="wifi_watchdog_network_disabled" msgid="7904214231651546347">"Problem prilikom spajanja na WiFi mrežu"</string>
    <string name="wifi_watchdog_network_disabled_detailed" msgid="4917472096696322767">" ima lošu internetsku vezu."</string>
    <string name="wifi_connect_alert_title" msgid="8455846016001810172">"Želite li dozvoliti povezivanje?"</string>
    <string name="wifi_connect_alert_message" msgid="6451273376815958922">"Aplikacija %1$s se želi povezati na WiFi mrežu %2$s"</string>
    <string name="wifi_connect_default_application" msgid="7143109390475484319">"Aplikacija"</string>
    <string name="wifi_p2p_dialog_title" msgid="97611782659324517">"WiFi Direct"</string>
    <string name="wifi_p2p_turnon_message" msgid="2909250942299627244">"Pokreni WiFi Direct. To će isključiti WiFi klijenta/pristupnu tačku."</string>
    <string name="wifi_p2p_failed_message" msgid="3763669677935623084">"Greška u pokretanju opcije WiFi Direct."</string>
    <string name="wifi_p2p_enabled_notification_title" msgid="2068321881673734886">"WiFi Direct je uključen"</string>
    <string name="wifi_p2p_enabled_notification_message" msgid="8064677407830620023">"Dodirnite za postavke"</string>
    <string name="accept" msgid="1645267259272829559">"Prihvati"</string>
    <string name="decline" msgid="2112225451706137894">"Odbijte"</string>
    <string name="wifi_p2p_invitation_sent_title" msgid="1318975185112070734">"Pozivnica poslana"</string>
    <string name="wifi_p2p_invitation_to_connect_title" msgid="4958803948658533637">"Pozivnica za povezivanje"</string>
    <string name="wifi_p2p_from_message" msgid="570389174731951769">"Od:"</string>
    <string name="wifi_p2p_to_message" msgid="248968974522044099">"Prima:"</string>
    <string name="wifi_p2p_enter_pin_message" msgid="5920929550367828970">"Unesite potrebni 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 privremeno prekinuti WiFi vezu dok bude povezan s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_p2p_frequency_conflict_message" product="tv" msgid="3087858235069421128">"TV će privremeno prekinuti WiFi vezu 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 privremeno prekinuti WiFi vezu dok bude povezan s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="select_character" msgid="3365550120617701745">"Umetni karakter"</string>
    <string name="sms_control_title" msgid="7296612781128917719">"Slanje SMS poruka"</string>
    <string name="sms_control_message" msgid="3867899169651496433">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; šalje veliki broj SMS poruka. Da li želite dozvoliti ovoj aplikaciji da nastavi slanje poruka?"</string>
    <string name="sms_control_yes" msgid="3663725993855816807">"Dozvoli"</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 adresu &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="5873295990846059400">"Ovo "<b>"može uzrokovati troškove"</b>" na vašem računu za mobilne usluge."</string>
    <string name="sms_premium_short_code_details" msgid="7869234868023975"><b>"Ovo će uzrokovati troškove na vašem računu za mobilne usluge."</b></string>
    <string name="sms_short_code_confirm_allow" msgid="4458878637111023413">"Pošalji"</string>
    <string name="sms_short_code_confirm_deny" msgid="2927389840209170706">"Otkaži"</string>
    <string name="sms_short_code_remember_choice" msgid="5289538592272218136">"Zapamti moj izbor"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="4960944133052287484">"Ovo možete kasnije promijeniti u meniju Postavke &gt; Aplikacije"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="3241181154869493368">"Uvijek dozvoli"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="446992765774269673">"Nikada ne dozvoli"</string>
    <string name="sim_removed_title" msgid="6227712319223226185">"SIM kartica uklonjena"</string>
    <string name="sim_removed_message" msgid="2333164559970958645">"Mobilna mreža bit će nedostupna do ponovnog pokretanja s umetnutom 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="6599945301141050216">"Za pristup mobilnoj mreži ponovo pokrenite uređaj."</string>
    <string name="sim_restart_button" msgid="4722407842815232347">"Ponovo pokreni"</string>
    <string name="install_carrier_app_notification_title" msgid="9056007111024059888">"Aktivirajte uslugu mobilne mreže"</string>
    <string name="install_carrier_app_notification_text" msgid="3346681446158696001">"Preuzmite aplikaciju operatera da aktivirate novi SIM"</string>
    <string name="install_carrier_app_notification_text_app_name" msgid="1196505084835248137">"Preuzmite aplikaciju <xliff:g id="APP_NAME">%1$s</xliff:g> da aktivirate novi SIM"</string>
    <string name="install_carrier_app_notification_button" msgid="3094206295081900849">"Preuzmite aplikaciju"</string>
    <string name="carrier_app_notification_title" msgid="8921767385872554621">"Nova SIM kartica je umetnuta"</string>
    <string name="carrier_app_notification_text" msgid="1132487343346050225">"Dodirnite da biste postavili"</string>
    <string name="time_picker_dialog_title" msgid="8349362623068819295">"Postavljanje vremena"</string>
    <string name="date_picker_dialog_title" msgid="5879450659453782278">"Postavljanje datuma"</string>
    <string name="date_time_set" msgid="5777075614321087758">"Postaviti"</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">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> omogućava."</string>
    <string name="no_permissions" msgid="7283357728219338112">"Nisu potrebna odobrenja"</string>
    <string name="perm_costs_money" msgid="4902470324142151116">"ovo se možda dodatno plaća"</string>
    <string name="dlg_ok" msgid="7376953167039865701">"Uredu"</string>
    <string name="usb_charging_notification_title" msgid="1595122345358177163">"Punjenje uređaja putem USB-a"</string>
    <string name="usb_supplying_notification_title" msgid="4631045789893086181">"Punjenje povezanog uređaja putem USB-a"</string>
    <string name="usb_mtp_notification_title" msgid="4238227258391151029">"Uključen je način rada Prijenos fajlova putem USB-a"</string>
    <string name="usb_ptp_notification_title" msgid="5425857879922006878">"Uključen je način rada PTP putem USB-a"</string>
    <string name="usb_tether_notification_title" msgid="3716143122035802501">"Uključen je način rada Povezivanje mobitela putem USB-a"</string>
    <string name="usb_midi_notification_title" msgid="5356040379749154805">"Uključen je način rada MIDI putem USB-a"</string>
    <string name="usb_accessory_notification_title" msgid="1785694450621427730">"Povezan je USB periferni uređaj"</string>
    <string name="usb_notification_message" msgid="3370903770828407960">"Dodirnite za više opcija."</string>
    <string name="usb_power_notification_message" msgid="4647527153291917218">"Punjenje povezanog uređaja. Dodirnite za više opcija."</string>
    <string name="usb_unsupported_audio_accessory_title" msgid="3529881374464628084">"Otkriven je analogni periferni uređaj"</string>
    <string name="usb_unsupported_audio_accessory_message" msgid="6309553946441565215">"Priključeni uređaj nije kompatibilan s ovim telefonom. Dodirnite da saznate više."</string>
    <string name="adb_active_notification_title" msgid="6729044778949189918">"Otklanjanje grešaka putem uređaja spojenog na USB je uspostavljeno"</string>
    <string name="adb_active_notification_message" msgid="7463062450474107752">"Dodirnite da isključite otklanjanje grešaka putem USB-a"</string>
    <string name="adb_active_notification_message" product="tv" msgid="8470296818270110396">"Odaberite da onemogućite ispravljanje grešaka koristeći USB"</string>
    <string name="test_harness_mode_notification_title" msgid="2216359742631914387">"Omogućen način rada okvira za testiranje"</string>
    <string name="test_harness_mode_notification_message" msgid="1343197173054407119">"Izvršite vraćanje na fabričke postavke da onemogućite način rada okvira za testiranje."</string>
    <string name="usb_contaminant_detected_title" msgid="7136400633704058349">"Tečnost ili nečistoće u USB priključku"</string>
    <string name="usb_contaminant_detected_message" msgid="832337061059487250">"USB priključak je automatski onemogućen. Dodirnite da saznate više."</string>
    <string name="usb_contaminant_not_detected_title" msgid="7708281124088684821">"USB priključak je sada sigurno koristiti"</string>
    <string name="usb_contaminant_not_detected_message" msgid="2415791798244545292">"Telefon više ne detektira tečnost ili nečistoće."</string>
    <string name="taking_remote_bugreport_notification_title" msgid="6742483073875060934">"Prijem izvještaja o grešci..."</string>
    <string name="share_remote_bugreport_notification_title" msgid="4987095013583691873">"Podijeliti izvještaj o grešci?"</string>
    <string name="sharing_remote_bugreport_notification_title" msgid="7572089031496651372">"Dijeljenje izvještaja o grešci..."</string>
    <string name="share_remote_bugreport_notification_message_finished" msgid="6029609949340992866">"Vaš administrator je zatražio izvještaj o greškama kako bi pomogao u rješavanju problema ovog uređaja. Moguće je dijeljenje aplikacija i podataka."</string>
    <string name="share_remote_bugreport_action" msgid="6249476773913384948">"PODIJELI"</string>
    <string name="decline_remote_bugreport_action" msgid="6230987241608770062">"ODBACI"</string>
    <string name="select_input_method" msgid="4653387336791222978">"Odabir načina unosa"</string>
    <string name="show_ime" msgid="2506087537466597099">"Prikaži na ekranu dok je fizička tastatura aktivna"</string>
    <string name="hardware" msgid="194658061510127999">"Prikaz virtuelne tastature"</string>
    <string name="select_keyboard_layout_notification_title" msgid="597189518763083494">"Konfiguriraj fizičku tastaturu"</string>
    <string name="select_keyboard_layout_notification_message" msgid="8084622969903004900">"Dodirnite za odabir jezika i rasporeda"</string>
    <string name="fast_scroll_alphabet" msgid="5433275485499039199">" ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="4030170524595123610">" 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="alert_windows_notification_channel_group_name" msgid="1463953341148606396">"Prikazivanje preko drugih aplikacija"</string>
    <string name="alert_windows_notification_channel_name" msgid="3116610965549449803">"Aplikacija <xliff:g id="NAME">%s</xliff:g> prekriva ostale aplikacije"</string>
    <string name="alert_windows_notification_title" msgid="3697657294867638947">"Aplikacija <xliff:g id="NAME">%s</xliff:g> prekriva druge apl."</string>
    <string name="alert_windows_notification_message" msgid="8917232109522912560">"Ako ne želite da <xliff:g id="NAME">%s</xliff:g> koristi ovu funkciju, dodirnite da otvorite postavke i isključite je."</string>
    <string name="alert_windows_notification_turn_off_action" msgid="2902891971380544651">"Isključi"</string>
    <string name="ext_media_checking_notification_title" msgid="4411133692439308924">"Provjeravanje medija <xliff:g id="NAME">%s</xliff:g>…"</string>
    <string name="ext_media_checking_notification_message" msgid="410185170877285434">"Pregledanje trenutnog sadržaja"</string>
    <string name="ext_media_new_notification_title" msgid="1621805083736634077">"Novi medij <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_new_notification_message" msgid="3673685270558405087">"Dodirnite za postavke"</string>
    <string name="ext_media_ready_notification_message" msgid="4083398150380114462">"Za prebacivanje slika i medijskih fajlova"</string>
    <string name="ext_media_unmountable_notification_title" msgid="4179418065210797130">"Problem s medijem <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unmountable_notification_message" msgid="4193858924381066522">"Dodirnite da popravite"</string>
    <string name="ext_media_unmountable_notification_message" product="tv" msgid="3941179940297874950">"Uređaj <xliff:g id="NAME">%s</xliff:g> je oštećen. Odaberite za popravak."</string>
    <string name="ext_media_unsupported_notification_title" msgid="3797642322958803257">"Uređaj <xliff:g id="NAME">%s</xliff:g> nije podržan"</string>
    <string name="ext_media_unsupported_notification_message" msgid="6121601473787888589">"Ovaj uređaj ne podržava uređaj <xliff:g id="NAME">%s</xliff:g>. Dodirnite da biste ga postavili u podržanom formatu."</string>
    <string name="ext_media_unsupported_notification_message" product="tv" msgid="3725436899820390906">"Ovaj uređaj ne podržava uređaj <xliff:g id="NAME">%s</xliff:g>. Dodirnite da ga postavite u podržanom formatu."</string>
    <string name="ext_media_badremoval_notification_title" msgid="3206248947375505416">"Neočekivano uklonjen uređaj <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_badremoval_notification_message" msgid="8556885808951260574">"Izbacite medij prije uklanjanja da izbjegnete gubitak sadržaja"</string>
    <string name="ext_media_nomedia_notification_title" msgid="6593814191061956856">"Medij <xliff:g id="NAME">%s</xliff:g> je uklonjen"</string>
    <string name="ext_media_nomedia_notification_message" msgid="2110883356419799994">"Neke funkcionalnosti možda neće raditi ispravno. Ubacite novu pohranu."</string>
    <string name="ext_media_unmounting_notification_title" msgid="5046532339291216076">"Izbacivanje medija <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unmounting_notification_message" msgid="1003926904442321115">"Nemojte uklanjati"</string>
    <string name="ext_media_init_action" msgid="7952885510091978278">"Postavi"</string>
    <string name="ext_media_unmount_action" msgid="1121883233103278199">"Izbaci"</string>
    <string name="ext_media_browse_action" msgid="8322172381028546087">"Istraži"</string>
    <string name="ext_media_seamless_action" msgid="6575980560886881233">"Prebacite izlaz"</string>
    <string name="ext_media_missing_title" msgid="620980315821543904">"<xliff:g id="NAME">%s</xliff:g> nedostaje"</string>
    <string name="ext_media_missing_message" msgid="4012389235250987930">"Ponovo ubacite uređaj"</string>
    <string name="ext_media_move_specific_title" msgid="1471100343872375842">"Premješta se <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_title" msgid="1022809140035962662">"Premještanje podataka"</string>
    <string name="ext_media_move_success_title" msgid="7863652232242276066">"Prijenos sadržaja je završen"</string>
    <string name="ext_media_move_success_message" msgid="8939137931961728009">"Sadržaj je premješten na uređaj <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_failure_title" msgid="1604422634177382092">"Nije moguće premjestiti sadržaj"</string>
    <string name="ext_media_move_failure_message" msgid="7388950499623016135">"Pokušajte ponovo premjestiti sadržaj"</string>
    <string name="ext_media_status_removed" msgid="6576172423185918739">"Uređaj je uklonjen"</string>
    <string name="ext_media_status_unmounted" msgid="2551560878416417752">"Uređaj je izbačen"</string>
    <string name="ext_media_status_checking" msgid="6193921557423194949">"Provjerava se..."</string>
    <string name="ext_media_status_mounted" msgid="7253821726503179202">"Uređaj je spreman"</string>
    <string name="ext_media_status_mounted_ro" msgid="8020978752406021015">"Samo za čitanje"</string>
    <string name="ext_media_status_bad_removal" msgid="8395398567890329422">"Uređaj je uklonjen na nebezbjedan način"</string>
    <string name="ext_media_status_unmountable" msgid="805594039236667894">"Uređaj je oštećen"</string>
    <string name="ext_media_status_unsupported" msgid="4691436711745681828">"Uređaj nije podržan"</string>
    <string name="ext_media_status_ejecting" msgid="5463887263101234174">"Izbacuje se..."</string>
    <string name="ext_media_status_formatting" msgid="1085079556538644861">"Formatira se..."</string>
    <string name="ext_media_status_missing" msgid="5638633895221670766">"Uređaj nije ubačen"</string>
    <string name="activity_list_empty" msgid="1675388330786841066">"Nije pronađena nijedna odgovarajuća aktivnost."</string>
    <string name="permlab_route_media_output" msgid="6243022988998972085">"usmjeravanje izlaza za medijske fajlove"</string>
    <string name="permdesc_route_media_output" msgid="4932818749547244346">"Omogućava aplikaciji usmjeravanje izlaza sa medija na druge vanjske uređaje."</string>
    <string name="permlab_readInstallSessions" msgid="3713753067455750349">"čitanje sesija instaliranja"</string>
    <string name="permdesc_readInstallSessions" msgid="2049771699626019849">"Dozvoljava aplikaciji da čita sesije instalacija. Ovim se aplikaciji omogućava da vidi detalje o aktivnim instalacijama paketa."</string>
    <string name="permlab_requestInstallPackages" msgid="5782013576218172577">"zahtijevanje paketa za instaliranje"</string>
    <string name="permdesc_requestInstallPackages" msgid="5740101072486783082">"Omogućava aplikaciji da zahtijeva instalaciju paket ā."</string>
    <string name="permlab_requestDeletePackages" msgid="1703686454657781242">"zatraži brisanje paketanja"</string>
    <string name="permdesc_requestDeletePackages" msgid="3406172963097595270">"Omogućava aplikaciji da zatraži brisanje paketa."</string>
    <string name="permlab_requestIgnoreBatteryOptimizations" msgid="8021256345643918264">"traži zanemarivanje optimizacije baterije"</string>
    <string name="permdesc_requestIgnoreBatteryOptimizations" msgid="8359147856007447638">"Omogućava aplikaciji da traži odobrenje za zanemarivanje optimizacije baterije za tu aplikaciju."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="1311810005957319690">"Dodirnite dvaput za kontrolu uvećanja"</string>
    <string name="gadget_host_error_inflating" msgid="4882004314906466162">"Dodavanje vidžeta nije uspjelo."</string>
    <string name="ime_action_go" msgid="8320845651737369027">"Započni"</string>
    <string name="ime_action_search" msgid="658110271822807811">"Pretraži"</string>
    <string name="ime_action_send" msgid="2316166556349314424">"Poslati"</string>
    <string name="ime_action_next" msgid="3138843904009813834">"Naprijed"</string>
    <string name="ime_action_done" msgid="8971516117910934605">"Gotovo"</string>
    <string name="ime_action_previous" msgid="1443550039250105948">"Naz."</string>
    <string name="ime_action_default" msgid="2840921885558045721">"Izvrši"</string>
    <string name="dial_number_using" msgid="5789176425167573586">"Biraj\nbroj <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="4947405226788104538">"Napraviti kontakt\nkoristeći broj <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="2106103817937859662">"Sljedeće aplikacije zahtijevaju odobrenje za pristup vašem računu, sada i u budućnosti."</string>
    <string name="grant_credentials_permission_message_footer" msgid="3125211343379376561">"Želite li dozvoliti taj zahtjev?"</string>
    <string name="grant_permissions_header_text" msgid="6874497408201826708">"Zahtjev za pristup"</string>
    <string name="allow" msgid="7225948811296386551">"Dozvoli"</string>
    <string name="deny" msgid="2081879885755434506">"Odbij"</string>
    <string name="permission_request_notification_title" msgid="6486759795926237907">"Upućen zahtjev za odobrenje"</string>
    <string name="permission_request_notification_with_subtitle" msgid="8530393139639560189">"Upućen zahtjev za dozvolu\nza račun <xliff:g id="ACCOUNT">%s</xliff:g>."</string>
    <string name="forward_intent_to_owner" msgid="1207197447013960896">"Aplikaciju koristite van poslovnog profila"</string>
    <string name="forward_intent_to_work" msgid="621480743856004612">"Aplikaciju koristite u poslovnom profilu"</string>
    <string name="input_method_binding_label" msgid="1283557179944992649">"Način unosa"</string>
    <string name="sync_binding_label" msgid="3687969138375092423">"Sinhrona"</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">"Promijenite pozadinsku sliku"</string>
    <string name="notification_listener_binding_label" msgid="2014162835481906429">"Usluga za praćenje obavještenja"</string>
    <string name="vr_listener_binding_label" msgid="4316591939343607306">"VR slušalac"</string>
    <string name="condition_provider_service_binding_label" msgid="1321343352906524564">"Pružalac uslova"</string>
    <string name="notification_ranker_binding_label" msgid="774540592299064747">"Usluga rangiranja obavještenja"</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> je aktivirala VPN"</string>
    <string name="vpn_text" msgid="1610714069627824309">"Dodirnite da upravljate mrežom."</string>
    <string name="vpn_text_long" msgid="4907843483284977618">"Povezano sa sesijom <xliff:g id="SESSION">%s</xliff:g>. Dodirnite da upravljate mrežom."</string>
    <string name="vpn_lockdown_connecting" msgid="6443438964440960745">"Povezivanje na uvijek aktivni VPN…"</string>
    <string name="vpn_lockdown_connected" msgid="8202679674819213931">"Povezan na uvijek aktivni VPN"</string>
    <string name="vpn_lockdown_disconnected" msgid="735805531187559719">"Prekinuta je veza s uvijek uključenim VPN-om"</string>
    <string name="vpn_lockdown_error" msgid="3133844445659711681">"Povezivanje na stalno uključen VPN nije uspjelo na stalno uključen VPN"</string>
    <string name="vpn_lockdown_config" msgid="8151951501116759194">"Promijenite postavke mreže ili VPN-a"</string>
    <string name="upload_file" msgid="2897957172366730416">"Odabir fajla"</string>
    <string name="no_file_chosen" msgid="6363648562170759465">"Nije izabran nijedan fajl"</string>
    <string name="reset" msgid="2448168080964209908">"Vrati na zadano"</string>
    <string name="submit" msgid="1602335572089911941">"Potvrdi"</string>
    <string name="car_mode_disable_notification_title" msgid="5704265646471239078">"Aplikacija za vožnju je pokrenuta"</string>
    <string name="car_mode_disable_notification_message" msgid="7647248420931129377">"Dodirnite za izlaz iz aplikacije za vožnju."</string>
    <string name="tethered_notification_title" msgid="3146694234398202601">"Uređaj dijeli vezu ili djeluje kao pristupna tačka"</string>
    <string name="tethered_notification_message" msgid="2113628520792055377">"Dodirnite za postavke"</string>
    <string name="disable_tether_notification_title" msgid="7526977944111313195">"Povezivanje putem mobitela je onemogućeno"</string>
    <string name="disable_tether_notification_message" msgid="2913366428516852495">"Kontaktirajte svog administratora za dodatne detalje"</string>
    <string name="back_button_label" msgid="2300470004503343439">"Nazad"</string>
    <string name="next_button_label" msgid="1080555104677992408">"Naprijed"</string>
    <string name="skip_button_label" msgid="1275362299471631819">"Preskoči"</string>
    <string name="no_matches" msgid="8129421908915840737">"Nema podudaranja"</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_erasing" msgid="2569962663843586562">"Brisanje dijeljene pohrane…"</string>
    <string name="share" msgid="1778686618230011964">"Podijelite"</string>
    <string name="find" msgid="4808270900322985960">"Pronađi"</string>
    <string name="websearch" msgid="4337157977400211589">"Internet pretraživanje"</string>
    <string name="find_next" msgid="5742124618942193978">"Nađi sljedeći"</string>
    <string name="find_previous" msgid="2196723669388360506">"Nađi prethodni"</string>
    <string name="gpsNotifTicker" msgid="5622683912616496172">"Korisnik <xliff:g id="NAME">%s</xliff:g> je poslao zahtjev za utvrđivanje lokacije"</string>
    <string name="gpsNotifTitle" msgid="5446858717157416839">"Zahtjev za lokaciju"</string>
    <string name="gpsNotifMessage" msgid="1374718023224000702">"Zahtjev uputio <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">"Granica za brisanje prekoračena"</string>
    <string name="sync_too_many_deletes_desc" msgid="496551671008694245">"Izbrisano je <xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g> stavki za <xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g>, račun <xliff:g id="ACCOUNT_NAME">%3$s</xliff:g>. Šta želite uraditi?"</string>
    <string name="sync_really_delete" msgid="2572600103122596243">"Izbriši stavke"</string>
    <string name="sync_undo_deletes" msgid="2941317360600338602">"Poništiti brisanje"</string>
    <string name="sync_do_nothing" msgid="3743764740430821845">"Ne radi ništa za sada"</string>
    <string name="choose_account_label" msgid="5655203089746423927">"Odaberite račun"</string>
    <string name="add_account_label" msgid="2935267344849993553">"Dodaj račun"</string>
    <string name="add_account_button_label" msgid="3611982894853435874">"Dodajte račun"</string>
    <string name="number_picker_increment_button" msgid="2412072272832284313">"Povećaj"</string>
    <string name="number_picker_decrement_button" msgid="476050778386779067">"Smanji"</string>
    <string name="number_picker_increment_scroll_mode" msgid="5259126567490114216">"<xliff:g id="VALUE">%s</xliff:g> dodirnite i držite."</string>
    <string name="number_picker_increment_scroll_action" msgid="9101473045891835490">"Kliznite gore da povećate i dolje da smanjite."</string>
    <string name="time_picker_increment_minute_button" msgid="8865885114028614321">"Povećaj minute"</string>
    <string name="time_picker_decrement_minute_button" msgid="6246834937080684791">"Smanji minute"</string>
    <string name="time_picker_increment_hour_button" msgid="3652056055810223139">"Povećaj sate"</string>
    <string name="time_picker_decrement_hour_button" msgid="1377479863429214792">"Smanji sate"</string>
    <string name="time_picker_increment_set_pm_button" msgid="4147590696151230863">"Postavi za poslijepodne (PM)"</string>
    <string name="time_picker_decrement_set_am_button" msgid="8302140353539486752">"Postavi za prijepodne (AM)"</string>
    <string name="date_picker_increment_month_button" msgid="5369998479067934110">"Povećaj mjesece"</string>
    <string name="date_picker_decrement_month_button" msgid="1832698995541726019">"Smanji mjesece"</string>
    <string name="date_picker_increment_day_button" msgid="7130465412308173903">"Povećaj dane"</string>
    <string name="date_picker_decrement_day_button" msgid="4131881521818750031">"Smanji dane"</string>
    <string name="date_picker_increment_year_button" msgid="6318697384310808899">"Povećaj godine"</string>
    <string name="date_picker_decrement_year_button" msgid="4482021813491121717">"Smanji godine"</string>
    <string name="date_picker_prev_month_button" msgid="2858244643992056505">"Prethodni mjesec"</string>
    <string name="date_picker_next_month_button" msgid="5559507736887605055">"Sljedeći mjesec"</string>
    <string name="keyboardview_keycode_alt" msgid="4856868820040051939">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="1203984017245783244">"Otkaži"</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 rada"</string>
    <string name="keyboardview_keycode_shift" msgid="2270748814315147690">"Shift"</string>
    <string name="keyboardview_keycode_enter" msgid="2985864015076059467">"Potvrdi"</string>
    <string name="activitychooserview_choose_application" msgid="2125168057199941199">"Odaberite aplikaciju"</string>
    <string name="activitychooserview_choose_application_error" msgid="8624618365481126668">"Aplikacija <xliff:g id="APPLICATION_NAME">%s</xliff:g> se ne može pokrenuti."</string>
    <string name="shareactionprovider_share_with" msgid="806688056141131819">"Podijeliti sa"</string>
    <string name="shareactionprovider_share_with_application" msgid="5627411384638389738">"Dijeli pomoću aplikacije <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="415975056159262248">"Klizni regulator. Dodirnite &amp; držite."</string>
    <string name="description_target_unlock_tablet" msgid="3833195335629795055">"Prevucite za otključavanje ekrana."</string>
    <string name="action_bar_home_description" msgid="5293600496601490216">"Vratite se na početnu stranicu"</string>
    <string name="action_bar_up_description" msgid="2237496562952152589">"Navigirajte prema 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="3570990907910199483">"Interno dijeljena pohrana"</string>
    <string name="storage_sd_card" msgid="3282948861378286745">"SD kartica"</string>
    <string name="storage_sd_card_label" msgid="6347111320774379257">"<xliff:g id="MANUFACTURER">%s</xliff:g> SD kartica"</string>
    <string name="storage_usb_drive" msgid="6261899683292244209">"USB disk"</string>
    <string name="storage_usb_drive_label" msgid="4501418548927759953">"<xliff:g id="MANUFACTURER">%s</xliff:g> USB disk"</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="6499834033204801605">"Upozorenje o potrošnji podataka"</string>
    <string name="data_usage_warning_body" msgid="7340198905103751676">"Potrošili ste <xliff:g id="APP">%s</xliff:g> podataka"</string>
    <string name="data_usage_mobile_limit_title" msgid="6561099244084267376">"Dostignuto ograničenje za prijenos podataka"</string>
    <string name="data_usage_wifi_limit_title" msgid="5803363779034792676">"Dostignut limit WiFi podataka"</string>
    <string name="data_usage_limit_body" msgid="2908179506560812973">"Prijenos podataka je pauziran do kraja ciklusa"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="3171402244827034372">"Pređen limit mobilnih podataka"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="3547771791046344188">"Prekoračen limit WiFi podataka"</string>
    <string name="data_usage_limit_snoozed_body" msgid="1671222777207603301">"Prekoračili ste postavljeni limit od <xliff:g id="SIZE">%s</xliff:g>"</string>
    <string name="data_usage_restricted_title" msgid="5965157361036321914">"Pozadinski podaci su ograničeni"</string>
    <string name="data_usage_restricted_body" msgid="469866376337242726">"Dodirnite da biste uklonili ograničenja."</string>
    <string name="data_usage_rapid_title" msgid="1809795402975261331">"Velika potrošnja mobil. podataka"</string>
    <string name="data_usage_rapid_body" msgid="6897825788682442715">"Vaše aplikacije su potrošile više podataka nego obično"</string>
    <string name="data_usage_rapid_app_body" msgid="5396680996784142544">"Aplikacija <xliff:g id="APP">%s</xliff:g> je potrošila više podataka nego obično"</string>
    <string name="ssl_certificate" msgid="6510040486049237639">"Sigurnosni certifikat"</string>
    <string name="ssl_certificate_is_valid" msgid="6825263250774569373">"Ovaj certifikat je važeći."</string>
    <string name="issued_to" msgid="454239480274921032">"Primalac:"</string>
    <string name="common_name" msgid="2233209299434172646">"Ime domene:"</string>
    <string name="org_name" msgid="6973561190762085236">"Organizacija:"</string>
    <string name="org_unit" msgid="7265981890422070383">"Organizaciona jedinica:"</string>
    <string name="issued_by" msgid="2647584988057481566">"Izdao:"</string>
    <string name="validity_period" msgid="8818886137545983110">"Valjanost:"</string>
    <string name="issued_on" msgid="5895017404361397232">"Datum izdavanja:"</string>
    <string name="expires_on" msgid="3676242949915959821">"Ističe:"</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">"Odaberite aktivnost"</string>
    <string name="share_action_provider_share_with" msgid="5247684435979149216">"Podijeliti sa"</string>
    <string name="sending" msgid="3245653681008218030">"Slanje..."</string>
    <string name="launchBrowserDefault" msgid="2057951947297614725">"Pokretanje preglednika?"</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 ovaj put"</string>
    <string name="activity_resolver_app_settings" msgid="8965806928986509855">"Postavke"</string>
    <string name="activity_resolver_work_profiles_support" msgid="185598180676883455">"%1$s ne podržava poslovni profil"</string>
    <string name="default_audio_route_name" product="tablet" msgid="4617053898167127471">"Tablet"</string>
    <string name="default_audio_route_name" product="tv" msgid="9158088547603019321">"TV"</string>
    <string name="default_audio_route_name" product="default" msgid="4239291273420140123">"Telefon"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="6240602982276591864">"Zvučnici priključne stanice"</string>
    <string name="default_audio_route_name_hdmi" msgid="1486254205617081251">"HDMI"</string>
    <string name="default_audio_route_name_headphones" msgid="8119971843803439110">"Slušalice"</string>
    <string name="default_audio_route_name_usb" msgid="1234984851352637769">"USB"</string>
    <string name="default_audio_route_category_name" msgid="3722811174003886946">"Sistem"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="8575624030406771015">"Bluetooth audio"</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">"Poveži na uređaj"</string>
    <string name="media_route_chooser_title_for_remote_display" msgid="3395541745872017583">"Emitiranje ekrana 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 ekran"</string>
    <string name="display_manager_hdmi_display_name" msgid="1555264559227470109">"HDMI ekran"</string>
    <string name="display_manager_overlay_display_name" msgid="5142365982271620716">"Nadsloj #<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">", osigurano"</string>
    <string name="kg_forgot_pattern_button_text" msgid="8852021467868220608">"Zaboravili ste uzorak?"</string>
    <string name="kg_wrong_pattern" msgid="1850806070801358830">"Pogrešan uzorak"</string>
    <string name="kg_wrong_password" msgid="2333281762128113157">"Pogrešna lozinka"</string>
    <string name="kg_wrong_pin" msgid="1131306510833563801">"Pogrešan PIN"</string>
    <plurals name="kg_too_many_failed_attempts_countdown" formatted="false" msgid="8790651267324125694">
      <item quantity="one">Pokušajte ponovo za <xliff:g id="NUMBER">%d</xliff:g> sekundu.</item>
      <item quantity="few">Pokušajte ponovo za <xliff:g id="NUMBER">%d</xliff:g> sekunde.</item>
      <item quantity="other">Pokušajte ponovo za <xliff:g id="NUMBER">%d</xliff:g> sekundi.</item>
    </plurals>
    <string name="kg_pattern_instructions" msgid="398978611683075868">"Nacrtajte 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 lozinku"</string>
    <string name="kg_puk_enter_puk_hint" msgid="453227143861735537">"SIM je sada onemogućen. Unesite PUK kôd da nastavite. Za više informacija obratite se operateru."</string>
    <string name="kg_puk_enter_pin_hint" msgid="7871604527429602024">"Unesite željeni PIN"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="325676184762529976">"Potvrdi željeni PIN"</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">"Pogrešan PIN."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="8795159358110620001">"Unesite PIN koji sadrži od 4 do 8 brojeva."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="6025069204539532000">"PUK kôd bi trebao imati 8 brojeva."</string>
    <string name="kg_invalid_puk" msgid="3638289409676051243">"Ponovo unesite ispravan PUK kôd. Ponovljeni pokušaji će trajno onemogućiti SIM."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="7003469261464593516">"PIN-ovi se ne poklapaju"</string>
    <string name="kg_login_too_many_attempts" msgid="6486842094005698475">"Previše pokušaja otključavanja pomoću uzorka"</string>
    <string name="kg_login_instructions" msgid="1100551261265506448">"Da otključate, prijavite se pomoću svog Google računa."</string>
    <string name="kg_login_username_hint" msgid="5718534272070920364">"Korisničko ime (adresa e-pošte)"</string>
    <string name="kg_login_password_hint" msgid="9057289103827298549">"Lozinka"</string>
    <string name="kg_login_submit_button" msgid="5355904582674054702">"Prijava"</string>
    <string name="kg_login_invalid_input" msgid="5754664119319872197">"Pogrešno korisničko ime ili lozinka."</string>
    <string name="kg_login_account_recovery_hint" msgid="5690709132841752974">"Zaboravili ste korisničko ime ili lozinku?\nPosjetite "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="kg_login_checking_password" msgid="1052685197710252395">"Provjeravanje računa…"</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="8276745642049502550">"Pogrešno ste unijeli PIN <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. \n\nBroj sekundi do sljedećeg pokušaja: <xliff:g id="NUMBER_1">%2$d</xliff:g>."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="7813713389422226531">"Pogrešno ste unijeli lozinku <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. \n\nBroj sekundi do sljedećeg pokušaja: <xliff:g id="NUMBER_1">%2$d</xliff:g>."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="74089475965050805">"Pogrešno ste nacrtali uzorak <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. \n\nBroj sekundi do sljedećeg pokušaja: <xliff:g id="NUMBER_1">%2$d</xliff:g>."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="1575557200627128949">"Pokušali ste otključati tablet na pogrešan način <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. Ako napravite još <xliff:g id="NUMBER_1">%2$d</xliff:g> pokušaja bez uspjeha, tablet će biti vraćen na fabričke postavke i svi korisnički podaci će biti izgubljeni."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tv" msgid="5621231220154419413">"Pokušali ste <xliff:g id="NUMBER_0">%1$d</xliff:g> puta neispravno otključati TV. U slučaju još <xliff:g id="NUMBER_1">%2$d</xliff:g> pokušaja bez uspjeha, TV će biti vraćen na fabričke postavke i svi korisnički podaci će biti izgubljeni."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="4051015943038199910">"Pokušali ste otključati telefon na pogrešan način <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. Ako napravite još <xliff:g id="NUMBER_1">%2$d</xliff:g> pokušaja bez uspjeha, telefon će biti vraćen na fabričke postavke i svi korisnički podaci će biti izgubljeni."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="2072996269148483637">"Pokušali ste otključati tablet na pogrešan način <xliff:g id="NUMBER">%d</xliff:g> puta. Tablet će sada biti vraćen na fabričke postavke."</string>
    <string name="kg_failed_attempts_now_wiping" product="tv" msgid="4987878286750741463">"Pokušali ste <xliff:g id="NUMBER">%d</xliff:g> puta neispravno otključati TV. TV će sada biti vraćen na fabričke postavke."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="4817627474419471518">"Pokušali ste otključati telefon na pogrešan način <xliff:g id="NUMBER">%d</xliff:g> puta. Telefon će sada biti vraćen na fabričke postavke."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="3253575572118914370">"Pogrešno ste nacrtali uzorak za otključavanje <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. Ako napravite još <xliff:g id="NUMBER_1">%2$d</xliff:g> pokušaja bez uspjeha, od vas će se tražiti da otključate tablet pomoću e-pošte. \n\n Pokušajte ponovo za <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tv" msgid="4224651132862313471">"Uzorak za otključavanje ste pogrešno nacrtali <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. U slučaju još <xliff:g id="NUMBER_1">%2$d</xliff:g> pokušaja bez uspjeha, bit će zatraženo da TV otključate pomoću računa e-pošte.\n\n Pokušajte opet za <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="1437638152015574839">"Pogrešno ste nacrtali uzorak za otključavanje <xliff:g id="NUMBER_0">%1$d</xliff:g> puta. Ako napravite još <xliff:g id="NUMBER_1">%2$d</xliff:g> pokušaja bez uspjeha, od vas će se tražiti da otključate telefon pomoću e-pošte. \n\n Pokušajte ponovo za <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="kg_text_message_separator" product="default" msgid="4160700433287233771">" — "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="7899202978204438708">"Ukloni"</string>
    <string name="safe_media_volume_warning" product="default" msgid="2276318909314492312">"Želite li pojačati zvuk iznad preporučenog nivoa?\n\nDužim slušanjem glasnog zvuka možete oštetiti sluh."</string>
    <string name="accessibility_shortcut_warning_dialog_title" msgid="8404780875025725199">"Želite li koristiti Prečicu za pristupačnost?"</string>
    <string name="accessibility_shortcut_toogle_warning" msgid="7256507885737444807">"Kada je prečica uključena, pritiskom na oba dugmeta za podešavanje jačine zvuka u trajanju od 3 sekunde pokrenut će se funkcija za pristupačnost.\n\n Trenutna funkcija za pristupačnost je:\n <xliff:g id="SERVICE_NAME">%1$s</xliff:g>\n\n Funkciju možete promijeniti ako odete u Postavke &gt; Pristupačnost."</string>
    <string name="disable_accessibility_shortcut" msgid="627625354248453445">"Isključi prečicu"</string>
    <string name="leave_accessibility_shortcut_on" msgid="7653111894438512680">"Koristi prečicu"</string>
    <string name="color_inversion_feature_name" msgid="4231186527799958644">"Inverzija boja"</string>
    <string name="color_correction_feature_name" msgid="6779391426096954933">"Ispravka boja"</string>
    <string name="accessibility_shortcut_enabling_service" msgid="7771852911861522636">"Prečica za pristupačnost je uključila uslugu <xliff:g id="SERVICE_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_disabling_service" msgid="2747243438223109821">"Prečica za pristupačnost je isključila uslugu <xliff:g id="SERVICE_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_spoken_feedback" msgid="8376923232350078434">"Pritisnite obje tipke za podešavanje jačine zvuka i držite ih pritisnutim tri sekunde da koristite uslugu <xliff:g id="SERVICE_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_button_prompt_text" msgid="1176658502969738564">"Odaberite uslugu koja će se koristiti kada dodirnete dugme za pristupačnost:"</string>
    <string name="accessibility_gesture_prompt_text" msgid="8259145549733019401">"Odaberite uslugu koja će se koristiti kada izvedete pokret za pristupačnost (s dva prsta prevucite prema gore s dna ekrana):"</string>
    <string name="accessibility_gesture_3finger_prompt_text" msgid="1041435574275047665">"Odaberite uslugu koja će se koristiti kada izvedete pokret za pristupačnost (s tri prsta prevucite prema gore s dna ekrana):"</string>
    <string name="accessibility_button_instructional_text" msgid="7003212763213614833">"Da prebacujete između usluga, dodirnite i zadržite dugme za pristupačnost."</string>
    <string name="accessibility_gesture_instructional_text" msgid="5261788874937410950">"Da prebacujete između usluga, s dva prsta prevucite prema gore i zadržite."</string>
    <string name="accessibility_gesture_3finger_instructional_text" msgid="4969448938984394550">"Da prebacujete između usluga, s tri prsta prevucite prema gore i zadržite."</string>
    <string name="accessibility_magnification_chooser_text" msgid="1227146738764986237">"Uvećavanje"</string>
    <string name="user_switched" msgid="3768006783166984410">"Trenutni 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="user_logging_out_message" msgid="8939524935808875155">"Odjava 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">"Greška"</string>
    <string name="error_message_change_not_allowed" msgid="1238035947357923497">"Vaš administrator ne dozvoljava ovu promjenu"</string>
    <string name="app_not_found" msgid="3429141853498927379">"Nije pronađena aplikacija koja će upravljati ovom akcijom."</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">"Index Card 3x5"</string>
    <string name="mediasize_na_index_4x6" msgid="7687620625422312396">"Index Card 4x6"</string>
    <string name="mediasize_na_index_5x8" msgid="8834215284646872800">"Index Card 5x8"</string>
    <string name="mediasize_na_monarch" msgid="213639906956550754">"Monarch"</string>
    <string name="mediasize_na_quarto" msgid="835778493593023223">"Quarto"</string>
    <string name="mediasize_na_foolscap" msgid="1573911237983677138">"Foolscap"</string>
    <string name="mediasize_chinese_roc_8k" msgid="3626855847189438896">"ROC 8K"</string>
    <string name="mediasize_chinese_roc_16k" msgid="9182191577022943355">"ROC 16K"</string>
    <string name="mediasize_chinese_prc_1" msgid="4793232644980170500">"PRC 1"</string>
    <string name="mediasize_chinese_prc_2" msgid="5404109730975720670">"PRC 2"</string>
    <string name="mediasize_chinese_prc_3" msgid="1335092253339363526">"PRC 3"</string>
    <string name="mediasize_chinese_prc_4" msgid="9167997800486569834">"PRC 4"</string>
    <string name="mediasize_chinese_prc_5" msgid="845875168823541497">"PRC 5"</string>
    <string name="mediasize_chinese_prc_6" msgid="3220325667692648789">"PRC 6"</string>
    <string name="mediasize_chinese_prc_7" msgid="1776792138507038527">"PRC 7"</string>
    <string name="mediasize_chinese_prc_8" msgid="1417176642687456692">"PRC 8"</string>
    <string name="mediasize_chinese_prc_9" msgid="4785983473123798365">"PRC 9"</string>
    <string name="mediasize_chinese_prc_10" msgid="7847982299391851899">"PRC 10"</string>
    <string name="mediasize_chinese_prc_16k" msgid="262793383539980677">"PRC 16K"</string>
    <string name="mediasize_chinese_om_pa_kai" msgid="5256815579447959814">"Pa Kai"</string>
    <string name="mediasize_chinese_om_dai_pa_kai" msgid="7336412963441354407">"Dai Pa Kai"</string>
    <string name="mediasize_chinese_om_jurro_ku_kai" msgid="6324465444100490742">"Jurro Ku Kai"</string>
    <string name="mediasize_japanese_jis_b10" msgid="1787262845627694376">"JIS B10"</string>
    <string name="mediasize_japanese_jis_b9" msgid="3336035783663287470">"JIS B9"</string>
    <string name="mediasize_japanese_jis_b8" msgid="6195398299104345731">"JIS B8"</string>
    <string name="mediasize_japanese_jis_b7" msgid="1674621886902828884">"JIS B7"</string>
    <string name="mediasize_japanese_jis_b6" msgid="4170576286062657435">"JIS B6"</string>
    <string name="mediasize_japanese_jis_b5" msgid="4899297958100032533">"JIS B5"</string>
    <string name="mediasize_japanese_jis_b4" msgid="4213158129126666847">"JIS B4"</string>
    <string name="mediasize_japanese_jis_b3" msgid="8513715307410310696">"JIS B3"</string>
    <string name="mediasize_japanese_jis_b2" msgid="4777690211897131190">"JIS B2"</string>
    <string name="mediasize_japanese_jis_b1" msgid="4608142385457034603">"JIS B1"</string>
    <string name="mediasize_japanese_jis_b0" msgid="7587108366572243991">"JIS B0"</string>
    <string name="mediasize_japanese_jis_exec" msgid="5244075432263649068">"JIS Exec"</string>
    <string name="mediasize_japanese_chou4" msgid="4941652015032631361">"Chou4"</string>
    <string name="mediasize_japanese_chou3" msgid="6387319169263957010">"Chou3"</string>
    <string name="mediasize_japanese_chou2" msgid="1299112025415343982">"Chou2"</string>
    <string name="mediasize_japanese_hagaki" msgid="8070115620644254565">"Hagaki"</string>
    <string name="mediasize_japanese_oufuku" msgid="6049065587307896564">"Oufuku"</string>
    <string name="mediasize_japanese_kahu" msgid="6872696027560065173">"Kahu"</string>
    <string name="mediasize_japanese_kaku2" msgid="2359077233775455405">"Kaku2"</string>
    <string name="mediasize_japanese_you4" msgid="2091777168747058008">"You4"</string>
    <string name="mediasize_unknown_portrait" msgid="3088043641616409762">"Neodređeni uspravni format"</string>
    <string name="mediasize_unknown_landscape" msgid="4876995327029361552">"Neodređeni vodoravni format"</string>
    <string name="write_fail_reason_cancelled" msgid="7091258378121627624">"Otkazano"</string>
    <string name="write_fail_reason_cannot_write" msgid="8132505417935337724">"Greška pri pisanju sadržaja"</string>
    <string name="reason_unknown" msgid="6048913880184628119">"nepoznat"</string>
    <string name="reason_service_unavailable" msgid="7824008732243903268">"Usluga štampanja nije omogućena."</string>
    <string name="print_service_installed_title" msgid="2246317169444081628">"Usluga <xliff:g id="NAME">%s</xliff:g> je instalirana"</string>
    <string name="print_service_installed_message" msgid="5897362931070459152">"Dodirnite da omogućite"</string>
    <string name="restr_pin_enter_admin_pin" msgid="8641662909467236832">"Upišite PIN administratora"</string>
    <string name="restr_pin_enter_pin" msgid="3395953421368476103">"Unesite PIN"</string>
    <string name="restr_pin_incorrect" msgid="8571512003955077924">"Netačno"</string>
    <string name="restr_pin_enter_old_pin" msgid="1462206225512910757">"Trenutni PIN"</string>
    <string name="restr_pin_enter_new_pin" msgid="5959606691619959184">"Novi PIN"</string>
    <string name="restr_pin_confirm_pin" msgid="8501523829633146239">"Potvrdi novi PIN"</string>
    <string name="restr_pin_create_pin" msgid="8017600000263450337">"Kreiraj 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 najmanje 4 cifre."</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_cling_title" msgid="8394201622932303336">"Prikazuje se cijeli ekran"</string>
    <string name="immersive_cling_description" msgid="3482371193207536040">"Da izađete, prevucite odozgo nadolje."</string>
    <string name="immersive_cling_positive" msgid="5016839404568297683">"Razumijem"</string>
    <string name="done_label" msgid="2093726099505892398">"Gotovo"</string>
    <string name="hour_picker_description" msgid="6698199186859736512">"Kružni klizač za odabir sata"</string>
    <string name="minute_picker_description" msgid="8606010966873791190">"Kružni klizač za minute"</string>
    <string name="select_hours" msgid="6043079511766008245">"Odaberite sat"</string>
    <string name="select_minutes" msgid="3974345615920336087">"Odaberite minute"</string>
    <string name="select_day" msgid="7774759604701773332">"Odaberite mjesec i dan"</string>
    <string name="select_year" msgid="7952052866994196170">"Odaberite godinu"</string>
    <string name="deleted_key" msgid="7659477886625566590">"Broj <xliff:g id="KEY">%1$s</xliff:g> je izbrisan"</string>
    <string name="managed_profile_label_badge" msgid="2355652472854327647">"Poslovni <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="managed_profile_label_badge_2" msgid="5048136430082124036">"2. poslovni <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="managed_profile_label_badge_3" msgid="2808305070321719040">"3. poslovni <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="lock_to_app_unlock_pin" msgid="2552556656504331634">"Traži PIN prije nego se otkači"</string>
    <string name="lock_to_app_unlock_pattern" msgid="4182192144797225137">"Traži uzorak za otključavanje prije poništavanja kačenja"</string>
    <string name="lock_to_app_unlock_password" msgid="6380979775916974414">"Traži lozinku prije nego se otkači"</string>
    <string name="package_installed_device_owner" msgid="6875717669960212648">"Instalirao je vaš administrator"</string>
    <string name="package_updated_device_owner" msgid="1847154566357862089">"Ažurirao je vaš administrator"</string>
    <string name="package_deleted_device_owner" msgid="2307122077550236438">"Izbrisao je vaš administrator"</string>
    <string name="confirm_battery_saver" msgid="639106420541753635">"Uredu"</string>
    <string name="battery_saver_description_with_learn_more" msgid="2108984221113106294">"U cilju produženja trajanja baterije, funkcija Ušteda baterije isključuje ili ograničava aktivnost u pozadini, neke vizuelne efekte i druge funkcije koje troše puno energije. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="battery_saver_description" msgid="6413346684861241431">"U cilju produženja trajanja baterije, funkcija Ušteda baterije isključuje ili ograničava aktivnost u pozadini, neke vizuelne efekte i druge funkcije koje troše puno energije."</string>
    <string name="data_saver_description" msgid="6015391409098303235">"Da bi se smanjio prijenos podataka, Ušteda podataka sprečava da neke aplikacije šalju ili primaju podatke u pozadini. Aplikacija koju trenutno koristite može pristupiti podacima, ali će to činiti rjeđe. To može značiti, naprimjer, da se slike ne prikazuju sve dok ih ne dodirnete."</string>
    <string name="data_saver_enable_title" msgid="4674073932722787417">"Uključiti Uštedu podataka?"</string>
    <string name="data_saver_enable_button" msgid="7147735965247211818">"Uključi"</string>
    <plurals name="zen_mode_duration_minutes_summary" formatted="false" msgid="4367877408072000848">
      <item quantity="one">%1$d minuta (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">%1$d minute (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d minuta (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_summary_short" formatted="false" msgid="6830154222366042597">
      <item quantity="one">%1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">%1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d min (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary" formatted="false" msgid="736789408293052283">
      <item quantity="one">Za %1$d sat (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">Za %1$d sata (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Za %1$d sati (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary_short" formatted="false" msgid="4787552595253082371">
      <item quantity="one">%1$d sat (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">%1$d sata (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">%1$d sati (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes" formatted="false" msgid="5127407202506485571">
      <item quantity="one">%d minuta</item>
      <item quantity="few">%d minute</item>
      <item quantity="other">%d minuta</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_short" formatted="false" msgid="2199350154433426128">
      <item quantity="one">%d min</item>
      <item quantity="few">%d min</item>
      <item quantity="other">%d min</item>
    </plurals>
    <plurals name="zen_mode_duration_hours" formatted="false" msgid="6571961796799076730">
      <item quantity="one">Za %d sat</item>
      <item quantity="few">Za %d sata</item>
      <item quantity="other">Za %d sati</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_short" formatted="false" msgid="6748277774662434217">
      <item quantity="one">%d sat</item>
      <item quantity="few">%d sata</item>
      <item quantity="other">%d sati</item>
    </plurals>
    <string name="zen_mode_until" msgid="7336308492289875088">"Do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_alarm" msgid="9128205721301330797">"Do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g> (sljedeći alarm)"</string>
    <string name="zen_mode_forever" msgid="931849471004038757">"Dok ne isključite"</string>
    <string name="zen_mode_forever_dnd" msgid="3792132696572189081">"Dok ne isključite način rada Ne ometaj"</string>
    <string name="zen_mode_rule_name_combination" msgid="191109939968076477">"<xliff:g id="FIRST">%1$s</xliff:g>/<xliff:g id="REST">%2$s</xliff:g>"</string>
    <string name="toolbar_collapse_description" msgid="2821479483960330739">"Suzi"</string>
    <string name="zen_mode_feature_name" msgid="5254089399895895004">"Ne ometaj"</string>
    <string name="zen_mode_downtime_feature_name" msgid="2626974636779860146">"Neaktivnost"</string>
    <string name="zen_mode_default_weeknights_name" msgid="3081318299464998143">"Radni dan uvečer"</string>
    <string name="zen_mode_default_weekends_name" msgid="2786495801019345244">"Vikend"</string>
    <string name="zen_mode_default_events_name" msgid="8158334939013085363">"Događaj"</string>
    <string name="zen_mode_default_every_night_name" msgid="3012363838882944175">"Spavanje"</string>
    <string name="muted_by" msgid="5942954724562097128">"<xliff:g id="THIRD_PARTY">%1$s</xliff:g> isključuje neke zvukove"</string>
    <string name="system_error_wipe_data" msgid="6608165524785354962">"Postoji problem u vašem uređaju i može biti nestabilan dok ga ne vratite na fabričke postavke."</string>
    <string name="system_error_manufacturer" msgid="8086872414744210668">"Postoji problem u vašem uređaju. Za više informacija obratite se proizvođaču."</string>
    <string name="stk_cc_ussd_to_dial" msgid="5214333646366591205">"USSD zahtjev je promijenjen u obični poziv"</string>
    <string name="stk_cc_ussd_to_ss" msgid="4884994189414782605">"USSD zahtjev je promijenjen u SS zahtjev"</string>
    <string name="stk_cc_ussd_to_ussd" msgid="5728637484565449312">"Promijenjeno u novi USSD zahtjev"</string>
    <string name="stk_cc_ussd_to_dial_video" msgid="4134455726513175559">"USSD zahtjev je promijenjen u video poziv"</string>
    <string name="stk_cc_ss_to_dial" msgid="1360775164651754978">"SS zahtjev je promijenjen u obični poziv"</string>
    <string name="stk_cc_ss_to_dial_video" msgid="6577956662913194947">"SS zahtjev je promijenjen u video poziv"</string>
    <string name="stk_cc_ss_to_ussd" msgid="5614626512855868785">"SS zahtjev je promijenjen u USSD zahtjev"</string>
    <string name="stk_cc_ss_to_ss" msgid="7716729801537709054">"Promijenjeno u novi SS zahtjev"</string>
    <string name="notification_work_profile_content_description" msgid="4600554564103770764">"Profil za posao"</string>
    <string name="notification_alerted_content_description" msgid="1296617716556420585">"Upozoreni"</string>
    <string name="expand_button_content_description_collapsed" msgid="3609784019345534652">"Proširi"</string>
    <string name="expand_button_content_description_expanded" msgid="8520652707158554895">"Suzi"</string>
    <string name="expand_action_accessibility" msgid="5307730695723718254">"aktiviraj/deaktiviraj proširenje"</string>
    <string name="usb_midi_peripheral_name" msgid="7221113987741003817">"Android USB ulaz za periferijske uređaje"</string>
    <string name="usb_midi_peripheral_manufacturer_name" msgid="7176526170008970168">"Android"</string>
    <string name="usb_midi_peripheral_product_name" msgid="4971827859165280403">"USB ulaz za periferijske uređaje"</string>
    <string name="floating_toolbar_open_overflow_description" msgid="4797287862999444631">"Još opcija"</string>
    <string name="floating_toolbar_close_overflow_description" msgid="559796923090723804">"Zatvori preklopni meni"</string>
    <string name="maximize_button_text" msgid="7543285286182446254">"Povećaj maksimalno"</string>
    <string name="close_button_text" msgid="3937902162644062866">"Zatvori"</string>
    <string name="notification_messaging_title_template" msgid="3452480118762691020">"<xliff:g id="CONVERSATION_TITLE">%1$s</xliff:g>: <xliff:g id="SENDER_NAME">%2$s</xliff:g>"</string>
    <plurals name="selected_count" formatted="false" msgid="7187339492915744615">
      <item quantity="one"><xliff:g id="COUNT_1">%1$d</xliff:g> stavka je odabrana</item>
      <item quantity="few"><xliff:g id="COUNT_1">%1$d</xliff:g> stavke su odabrane</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> stavki je odabrano</item>
    </plurals>
    <string name="default_notification_channel_label" msgid="5929663562028088222">"Nije kategorizirano"</string>
    <string name="importance_from_user" msgid="7318955817386549931">"Vi određujete značaj ovih obavještenja."</string>
    <string name="importance_from_person" msgid="9160133597262938296">"Ovo je značajno zbog osoba koje su uključene."</string>
    <string name="user_creation_account_exists" msgid="1942606193570143289">"Da li dozvoljavate aplikaciji <xliff:g id="APP">%1$s</xliff:g> da kreira novog korisnika s računom <xliff:g id="ACCOUNT">%2$s</xliff:g>?"</string>
    <string name="user_creation_adding" msgid="4482658054622099197">"Da li dozvoljavate da <xliff:g id="APP">%1$s</xliff:g> kreira novog korisnika za <xliff:g id="ACCOUNT">%2$s</xliff:g> (Korisnik sa ovim nalogom već postoji)?"</string>
    <string name="language_selection_title" msgid="2680677278159281088">"Dodajte jezik"</string>
    <string name="country_selection_title" msgid="2954859441620215513">"Izbor regije"</string>
    <string name="search_language_hint" msgid="7042102592055108574">"Upišite ime jezika"</string>
    <string name="language_picker_section_suggested" msgid="8414489646861640885">"Predloženo"</string>
    <string name="language_picker_section_all" msgid="3097279199511617537">"Svi jezici"</string>
    <string name="region_picker_section_all" msgid="8966316787153001779">"Sve regije"</string>
    <string name="locale_search_menu" msgid="2560710726687249178">"Pretraga"</string>
    <string name="app_suspended_title" msgid="2075071241147969611">"Aplikacija nije dostupna"</string>
    <string name="app_suspended_default_message" msgid="123166680425711887">"Aplikacija <xliff:g id="APP_NAME_0">%1$s</xliff:g> trenutno nije dostupna. Ovim upravlja aplikacija <xliff:g id="APP_NAME_1">%2$s</xliff:g>."</string>
    <string name="app_suspended_more_details" msgid="1131804827776778187">"Saznajte više"</string>
    <string name="work_mode_off_title" msgid="1118691887588435530">"Uključiti radni profil?"</string>
    <string name="work_mode_off_message" msgid="5130856710614337649">"Uključit će se poslovne aplikacije, obavještenja, podaci i druge funkcije radnog profila"</string>
    <string name="work_mode_turn_on" msgid="2062544985670564875">"Uključi"</string>
    <string name="deprecated_target_sdk_message" msgid="1449696506742572767">"Ova aplikacija je pravljena za stariju verziju Androida i možda neće ispravno raditi. Provjerite jesu li dostupna ažuriranja ili kontaktirajte programera."</string>
    <string name="deprecated_target_sdk_app_store" msgid="5032340500368495077">"Provjeri je li dostupno ažuriranje"</string>
    <string name="new_sms_notification_title" msgid="8442817549127555977">"Imate nove poruke"</string>
    <string name="new_sms_notification_content" msgid="7002938807812083463">"Otvorite SMS aplikaciju da biste pregledali poruke"</string>
    <string name="profile_encrypted_title" msgid="4260432497586829134">"Neke funkcije mogu biti ograničene"</string>
    <string name="profile_encrypted_detail" msgid="3700965619978314974">"Radni profil je zaključan"</string>
    <string name="profile_encrypted_message" msgid="6964994232310195874">"Dodirnite da biste otključali radni profil"</string>
    <string name="usb_mtp_launch_notification_title" msgid="8359219638312208932">"Povezan na uređaj <xliff:g id="PRODUCT_NAME">%1$s</xliff:g>"</string>
    <string name="usb_mtp_launch_notification_description" msgid="8541876176425411358">"Dodirnite za prikaz fajlova"</string>
    <string name="app_info" msgid="6856026610594615344">"Informacije o aplikaciji"</string>
    <string name="negative_duration" msgid="5688706061127375131">"−<xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="demo_starting_message" msgid="5268556852031489931">"Pokretanje demonstracije…"</string>
    <string name="demo_restarting_message" msgid="952118052531642451">"Vraćanje uređaja na početne postavke…"</string>
    <string name="suspended_widget_accessibility" msgid="6712143096475264190">"Onemogućen <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="conference_call" msgid="3751093130790472426">"Konferencijski poziv"</string>
    <string name="tooltip_popup_title" msgid="5253721848739260181">"Savjet za alat"</string>
    <string name="app_category_game" msgid="5431836943981492993">"Igre"</string>
    <string name="app_category_audio" msgid="1659853108734301647">"Muzika i zvuk"</string>
    <string name="app_category_video" msgid="2728726078629384196">"Filmovi i videozapisi"</string>
    <string name="app_category_image" msgid="4867854544519846048">"Fotografije i slike"</string>
    <string name="app_category_social" msgid="5842783057834965912">"Društvene mreže i komunikacija"</string>
    <string name="app_category_news" msgid="7496506240743986873">"Vijesti i časopisi"</string>
    <string name="app_category_maps" msgid="5878491404538024367">"Mape i navigacija"</string>
    <string name="app_category_productivity" msgid="3742083261781538852">"Produktivnost"</string>
    <string name="device_storage_monitor_notification_channel" msgid="3295871267414816228">"Memorija uređaja"</string>
    <string name="adb_debugging_notification_channel_tv" msgid="5537766997350092316">"Otklanjanje grešaka putem uređaja spojenog na USB"</string>
    <string name="time_picker_hour_label" msgid="2979075098868106450">"sat"</string>
    <string name="time_picker_minute_label" msgid="5168864173796598399">"minuta"</string>
    <string name="time_picker_header_text" msgid="143536825321922567">"Postavljanje vremena"</string>
    <string name="time_picker_input_error" msgid="7574999942502513765">"Unesite ispravno vrijeme"</string>
    <string name="time_picker_prompt_label" msgid="7588093983899966783">"Upišite vrijeme"</string>
    <string name="time_picker_text_input_mode_description" msgid="4148166758173708199">"Prebacite u način unosa teksta za unos vremena."</string>
    <string name="time_picker_radial_mode_description" msgid="4953403779779557198">"Prebacite u način rada kao sat za unos vremena."</string>
    <string name="autofill_picker_accessibility_title" msgid="8469043291648711535">"Opcije za automatsko popunjavanje"</string>
    <string name="autofill_save_accessibility_title" msgid="7244365268417107822">"Sačuvaj za automatsko popunjavanje"</string>
    <string name="autofill_error_cannot_autofill" msgid="7402758580060110371">"Sadržaje nije moguće automatski popuniti"</string>
    <string name="autofill_picker_no_suggestions" msgid="3908514303773350735">"Nema prijedloga za automatsko popunjavanje"</string>
    <plurals name="autofill_picker_some_suggestions" formatted="false" msgid="5506565809835815274">
      <item quantity="one"><xliff:g id="COUNT">%1$s</xliff:g> prijedlog za automatsko popunjavanje</item>
      <item quantity="few"><xliff:g id="COUNT">%1$s</xliff:g> prijedloga za automatsko popunjavanje</item>
      <item quantity="other"><xliff:g id="COUNT">%1$s</xliff:g> prijedloga za automatsko popunjavanje</item>
    </plurals>
    <string name="autofill_save_title" msgid="327541108460384555">"Sačuvati u "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_type" msgid="2339135393607143594">"Sačuvati <xliff:g id="TYPE">%1$s</xliff:g> u "<b>"<xliff:g id="LABEL">%2$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_2types" msgid="87616102361154432">"Sačuvati <xliff:g id="TYPE_0">%1$s</xliff:g> i <xliff:g id="TYPE_1">%2$s</xliff:g> u "<b>"<xliff:g id="LABEL">%3$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_3types" msgid="4108978552969604555">"Sačuvati <xliff:g id="TYPE_0">%1$s</xliff:g>, <xliff:g id="TYPE_1">%2$s</xliff:g> i <xliff:g id="TYPE_2">%3$s</xliff:g> u "<b>"<xliff:g id="LABEL">%4$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title" msgid="5305781141104585279">"Ažurirati u "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_type" msgid="4624181147422762233">"Ažurirati <xliff:g id="TYPE">%1$s</xliff:g> u "<b>"<xliff:g id="LABEL">%2$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_2types" msgid="2300113827053626484">"Ažurirati <xliff:g id="TYPE_0">%1$s</xliff:g> i <xliff:g id="TYPE_1">%2$s</xliff:g> u "<b>"<xliff:g id="LABEL">%3$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_3types" msgid="9089824354296211922">"Ažurirati ove stavke u "<b>"<xliff:g id="LABEL">%4$s</xliff:g>"</b>": <xliff:g id="TYPE_0">%1$s</xliff:g>, <xliff:g id="TYPE_1">%2$s</xliff:g> i <xliff:g id="TYPE_2">%3$s</xliff:g>?"</string>
    <string name="autofill_save_yes" msgid="6398026094049005921">"Sačuvaj"</string>
    <string name="autofill_save_no" msgid="2625132258725581787">"Ne, hvala"</string>
    <string name="autofill_update_yes" msgid="310358413273276958">"Ažuriraj"</string>
    <string name="autofill_save_type_password" msgid="5288448918465971568">"lozinka"</string>
    <string name="autofill_save_type_address" msgid="4936707762193009542">"adresa"</string>
    <string name="autofill_save_type_credit_card" msgid="7127694776265563071">"kreditna kartica"</string>
    <string name="autofill_save_type_username" msgid="239040540379769562">"korisničko ime"</string>
    <string name="autofill_save_type_email_address" msgid="5752949432129262174">"adresa e-pošte"</string>
    <string name="etws_primary_default_message_earthquake" msgid="5541962250262769193">"Ostanite smireni i potražite sklonište u blizini."</string>
    <string name="etws_primary_default_message_tsunami" msgid="1887685943498368548">"Odmah se evakuirajte iz priobalnih područja i područja oko rijeka na sigurnije mjesto kao što su viši predjeli."</string>
    <string name="etws_primary_default_message_earthquake_and_tsunami" msgid="998797956848445862">"Ostanite smireni i potražite sklonište u blizini."</string>
    <string name="etws_primary_default_message_test" msgid="2709597093560037455">"Test poruka za hitne slučajeve"</string>
    <string name="notification_reply_button_accessibility" msgid="3621714652387814344">"Odgovori"</string>
    <string name="etws_primary_default_message_others" msgid="6293148756130398971"></string>
    <string name="mmcc_authentication_reject" msgid="5767701075994754356">"SIM kartica nije dozvoljena za govor"</string>
    <string name="mmcc_imsi_unknown_in_hlr" msgid="5316658473301462825">"SIM kartica nije dodijeljena za govor"</string>
    <string name="mmcc_illegal_ms" msgid="807334478177362062">"SIM kartica nije dozvoljena za govor"</string>
    <string name="mmcc_illegal_me" msgid="1950705155760872972">"Telefon nije dozvoljen za govor"</string>
    <string name="mmcc_authentication_reject_msim_template" msgid="1217031195834766479">"SIM <xliff:g id="SIMNUMBER">%d</xliff:g> nije dozvoljen"</string>
    <string name="mmcc_imsi_unknown_in_hlr_msim_template" msgid="5636464607596778986">"SIM <xliff:g id="SIMNUMBER">%d</xliff:g> nije dodijeljen"</string>
    <string name="mmcc_illegal_ms_msim_template" msgid="5994323296399913454">"SIM <xliff:g id="SIMNUMBER">%d</xliff:g> nije dozvoljen"</string>
    <string name="mmcc_illegal_me_msim_template" msgid="5550259730350571826">"SIM <xliff:g id="SIMNUMBER">%d</xliff:g> nije dozvoljen"</string>
    <string name="popup_window_default_title" msgid="4874318849712115433">"Iskočni prozor"</string>
    <string name="slice_more_content" msgid="8504342889413274608">"+ <xliff:g id="NUMBER">%1$d</xliff:g>"</string>
    <string name="shortcut_restored_on_lower_version" msgid="4860853725206702336">"Instalirana je starija verzija aplikacije ili aplikacija nije kompatibilna s ovom prečicom"</string>
    <string name="shortcut_restore_not_supported" msgid="5028808567940014190">"Prečica nije uspješno vraćena jer aplikacija ne podržava izradu sigurnosne kopije i vraćanje"</string>
    <string name="shortcut_restore_signature_mismatch" msgid="2406209324521327518">"Prečica nije uspješno vraćena zbog nepodudaranja potpisa aplikacije"</string>
    <string name="shortcut_restore_unknown_issue" msgid="8703738064603262597">"Prečica nije uspješno vraćena"</string>
    <string name="shortcut_disabled_reason_unknown" msgid="5276016910284687075">"Prečica je onemogućena"</string>
    <string name="harmful_app_warning_uninstall" msgid="4837672735619532931">"DEINSTALIRAJ"</string>
    <string name="harmful_app_warning_open_anyway" msgid="596432803680914321">"IPAK OTVORI"</string>
    <string name="harmful_app_warning_title" msgid="8982527462829423432">"Otkrivena je štetna aplikacija"</string>
    <string name="slices_permission_request" msgid="8484943441501672932">"Aplikacija <xliff:g id="APP_0">%1$s</xliff:g> želi prikazati isječke aplikacije <xliff:g id="APP_2">%2$s</xliff:g>"</string>
    <string name="screenshot_edit" msgid="7867478911006447565">"Uredi"</string>
    <string name="volume_dialog_ringer_guidance_vibrate" msgid="8902050240801159042">"Pozivi i obavještenja će vibrirati"</string>
    <string name="volume_dialog_ringer_guidance_silent" msgid="2128975224280276122">"Pozivi i obavještenja će se isključiti"</string>
    <string name="notification_channel_system_changes" msgid="5072715579030948646">"Sistemske promjene"</string>
    <string name="notification_channel_do_not_disturb" msgid="6766940333105743037">"Ne ometaj"</string>
    <string name="zen_upgrade_notification_visd_title" msgid="3288313883409759733">"Novo: Način rada Ne ometaj sakriva obavještenja"</string>
    <string name="zen_upgrade_notification_visd_content" msgid="5533674060311631165">"Dodirnite da saznate više i izvršite promjene."</string>
    <string name="zen_upgrade_notification_title" msgid="3799603322910377294">"Način rada Ne ometaj je promijenjen"</string>
    <string name="zen_upgrade_notification_content" msgid="1794994264692424562">"Dodirnite da provjerite šta je blokirano."</string>
    <string name="notification_app_name_system" msgid="4205032194610042794">"Sistem"</string>
    <string name="notification_app_name_settings" msgid="7751445616365753381">"Postavke"</string>
    <string name="notification_appops_camera_active" msgid="5050283058419699771">"Kamera"</string>
    <string name="notification_appops_microphone_active" msgid="4335305527588191730">"Mikrofon"</string>
    <string name="notification_appops_overlay_active" msgid="633813008357934729">"prikazivanje preko drugih aplikacija na ekranu"</string>
    <string name="dynamic_mode_notification_channel_name" msgid="2348803891571320452">"Obavještenje za informacije Rutinskog načina"</string>
    <string name="dynamic_mode_notification_title" msgid="508815255807182035">"Moguće je da će se baterija isprazniti prije uobičajenog punjenja"</string>
    <string name="dynamic_mode_notification_summary" msgid="2541166298550402690">"Ušteda baterije je aktivirana da bi se produžio vijek trajanja baterije"</string>
    <string name="battery_saver_notification_channel_name" msgid="2083316159716201806">"Ušteda baterije"</string>
    <string name="battery_saver_sticky_disabled_notification_title" msgid="6376147579378764641">"Ušteda baterije se neće ponovo aktivirati dok se baterija ponovo ne isprazni"</string>
    <string name="battery_saver_sticky_disabled_notification_summary" msgid="8090192609249817945">"Baterija je dovoljno napunjena. Ušteda baterije se neće ponovo aktivirati dok se baterija ponovo ne isprazni."</string>
    <string name="battery_saver_charged_notification_title" product="default" msgid="2960978289873161288">"Telefon je napunjen <xliff:g id="CHARGE_LEVEL">%1$s</xliff:g>"</string>
    <string name="battery_saver_charged_notification_title" product="tablet" msgid="7555713825806482451">"Tablet je napunjen <xliff:g id="CHARGE_LEVEL">%1$s</xliff:g>"</string>
    <string name="battery_saver_charged_notification_title" product="device" msgid="5954873381559605660">"Uređaj je napunjen <xliff:g id="CHARGE_LEVEL">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_notification_summary" msgid="1374222493681267143">"Ušteda baterije je isključena. Funkcije nisu više ograničene."</string>
    <string name="battery_saver_off_alternative_notification_summary" msgid="4340727818546508436">"Ušteda baterije je isključena. Funkcije nisu više ograničene."</string>
    <string name="mime_type_folder" msgid="7111951698626315204">"Folder"</string>
    <string name="mime_type_apk" msgid="5518003630972506900">"Android aplikacija"</string>
    <string name="mime_type_generic" msgid="6833871596845900027">"Fajl"</string>
    <string name="mime_type_generic_ext" msgid="8450275970061657174">"<xliff:g id="EXTENSION">%1$s</xliff:g> fajl"</string>
    <string name="mime_type_audio" msgid="6289777657172050926">"Zvučni zapis"</string>
    <string name="mime_type_audio_ext" msgid="3270880987725816210">"<xliff:g id="EXTENSION">%1$s</xliff:g> zvučni zapis"</string>
    <string name="mime_type_video" msgid="4093025777317307426">"Videozapis"</string>
    <string name="mime_type_video_ext" msgid="5643771615714173159">"<xliff:g id="EXTENSION">%1$s</xliff:g> videozapis"</string>
    <string name="mime_type_image" msgid="3144284451605236371">"Slika"</string>
    <string name="mime_type_image_ext" msgid="1514613218742736590">"<xliff:g id="EXTENSION">%1$s</xliff:g> slika"</string>
    <string name="mime_type_compressed" msgid="1645486037074943257">"Arhiva"</string>
    <string name="mime_type_compressed_ext" msgid="4232293058067801528">"<xliff:g id="EXTENSION">%1$s</xliff:g> arhiva"</string>
    <string name="mime_type_document" msgid="1596838147256375966">"Dokument"</string>
    <string name="mime_type_document_ext" msgid="6327266601345501281">"<xliff:g id="EXTENSION">%1$s</xliff:g> dokument"</string>
    <string name="mime_type_spreadsheet" msgid="2639138255207123557">"Tabela"</string>
    <string name="mime_type_spreadsheet_ext" msgid="5508653032786106725">"<xliff:g id="EXTENSION">%1$s</xliff:g> tabela"</string>
    <string name="mime_type_presentation" msgid="6145604688774787357">"Prezentacija"</string>
    <string name="mime_type_presentation_ext" msgid="2982650207774823437">"<xliff:g id="EXTENSION">%1$s</xliff:g> prezentacija"</string>
    <string name="car_loading_profile" msgid="3545132581795684027">"Učitavanje"</string>
    <plurals name="file_count" formatted="false" msgid="1628600959752419449">
      <item quantity="one"><xliff:g id="FILE_NAME_2">%s</xliff:g> + <xliff:g id="COUNT_3">%d</xliff:g> fajl</item>
      <item quantity="few"><xliff:g id="FILE_NAME_2">%s</xliff:g> + <xliff:g id="COUNT_3">%d</xliff:g> fajla</item>
      <item quantity="other"><xliff:g id="FILE_NAME_2">%s</xliff:g> + <xliff:g id="COUNT_3">%d</xliff:g> fajlova</item>
    </plurals>
    <string name="chooser_no_direct_share_targets" msgid="997970693708458895">"Direktno dijeljenje nije dostupno"</string>
    <string name="chooser_all_apps_button_label" msgid="3631524352936289457">"Spisak aplikacija"</string>
</resources>
