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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="byteShort" msgid="202579285008794431">"B"</string>
    <string name="kilobyteShort" msgid="2214285521564195803">"kB"</string>
    <string name="megabyteShort" msgid="6649361267635823443">"MB"</string>
    <string name="gigabyteShort" msgid="7515809460261287991">"GB"</string>
    <string name="terabyteShort" msgid="1822367128583886496">"TB"</string>
    <string name="petabyteShort" msgid="5651571254228534832">"PB"</string>
    <string name="fileSizeSuffix" msgid="4233671691980131257">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="untitled" msgid="3381766946944136678">"&lt;Bez naslova&gt;"</string>
    <string name="emptyPhoneNumber" msgid="5812172618020360048">"(Nema broja telefona)"</string>
    <string name="unknownName" msgid="7078697621109055330">"Nepoznato"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2190754495304236490">"Govorna pošta"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2285034592902077488">"MSISDN1"</string>
    <string name="mmiError" msgid="2862759606579822246">"Problem sa povezivanjem ili nevažeći MMI kôd."</string>
    <string name="mmiFdnError" msgid="3975490266767565852">"Operacija je ograničena samo na brojeve fiksnog biranja."</string>
    <string name="mmiErrorWhileRoaming" msgid="1204173664713870114">"Nije moguće promijeniti postavke prosljeđivanja poziva s vašeg telefona dok ste u romingu."</string>
    <string name="serviceEnabled" msgid="7549025003394765639">"Usluga je omogućena."</string>
    <string name="serviceEnabledFor" msgid="1463104778656711613">"Usluga je omogućena za:"</string>
    <string name="serviceDisabled" msgid="641878791205871379">"Usluga je onemogućena."</string>
    <string name="serviceRegistered" msgid="3856192211729577482">"Registracija je uspješno izvršena."</string>
    <string name="serviceErased" msgid="997354043770513494">"Brisanje je uspješno izvršeno."</string>
    <string name="passwordIncorrect" msgid="917087532676155877">"Netačna lozinka."</string>
    <string name="mmiComplete" msgid="6341884570892520140">"MMI kôd izvršen."</string>
    <string name="badPin" msgid="888372071306274355">"Stari PIN koji ste unijeli nije ispravan."</string>
    <string name="badPuk" msgid="4232069163733147376">"PUK koji ste unijeli nije ispravan."</string>
    <string name="mismatchPin" msgid="2929611853228707473">"PIN-ovi koje ste unijeli se ne podudaraju."</string>
    <string name="invalidPin" msgid="7542498253319440408">"Unesite PIN koji sadrži 4 do 8 brojeva."</string>
    <string name="invalidPuk" msgid="8831151490931907083">"Unesite PUK koji sadrži 8 ili više brojeva."</string>
    <string name="needPuk" msgid="7321876090152422918">"SIM kartica je zaključana PUK-om. Unesite PUK kôd za otključavanje kartice."</string>
    <string name="needPuk2" msgid="7032612093451537186">"Unesite PUK2 kako biste deblokirali SIM karticu."</string>
    <string name="enablePin" msgid="2543771964137091212">"Nije uspjelo. Prvo omogućite SIM/RUIM zaključavanje."</string>
    <plurals name="pinpuk_attempts" formatted="false" msgid="1619867269012213584">
      <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="2157082351232630390">"IMEI"</string>
    <string name="meid" msgid="3291227361605924674">"MEID"</string>
    <string name="ClipMmi" msgid="4110549342447630629">"ID dolaznog poziva"</string>
    <string name="ClirMmi" msgid="6752346475055446417">"Sakrij odlazni ID pozivaoca"</string>
    <string name="ColpMmi" msgid="4736462893284419302">"Identifikacija povezane linije"</string>
    <string name="ColrMmi" msgid="5889782479745764278">"Ograničenje identifikacije povezane linije"</string>
    <string name="CfMmi" msgid="8390012691099787178">"Prosljeđivanje poziva"</string>
    <string name="CwMmi" msgid="3164609577675404761">"Poziv na čekanju"</string>
    <string name="BaMmi" msgid="7205614070543372167">"Zabrana poziva"</string>
    <string name="PwdMmi" msgid="3360991257288638281">"Promjena lozinke"</string>
    <string name="PinMmi" msgid="7133542099618330959">"Promjena PIN-a"</string>
    <string name="CnipMmi" msgid="4897531155968151160">"Broj pozivaoca dostupan"</string>
    <string name="CnirMmi" msgid="885292039284503036">"Broj pozivaoca zabranjen"</string>
    <string name="ThreeWCMmi" msgid="2436550866139999411">"Poziv između tri osobe"</string>
    <string name="RuacMmi" msgid="1876047385848991110">"Odbijanje neželjenih i dosadnih poziva"</string>
    <string name="CndMmi" msgid="185136449405618437">"Isporuka broja pozivaoca"</string>
    <string name="DndMmi" msgid="8797375819689129800">"Ne ometaj"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="4511621022859867988">"Prikaz ID-a pozivaoca u zadanim postavkama zabranjen. Sljedeći poziv: zabranjen"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="5036749051007098105">"Prikaz ID-a pozivaoca u zadanim postavkama zabranjen. Sljedeći poziv: nije zabranjen"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="1022781126694885017">"Prikaz ID-a pozivaoca u zadanim postavkama nije zabranjen. Sljedeći poziv: zabranjen"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2491576172356463443">"Prikaz ID-a pozivaoca u zadanim postavkama nije zabranjen. Sljedeći poziv: nije zabranjen"</string>
    <string name="serviceNotProvisioned" msgid="8289333510236766193">"Uslugu nije moguće koristiti."</string>
    <string name="CLIRPermanent" msgid="166443681876381118">"Ne možete promijeniti postavke ID-a pozivaoca."</string>
    <string name="RestrictedOnDataTitle" msgid="1500576417268169774">"Nema usluge prijenosa podataka na mobilnoj mreži"</string>
    <string name="RestrictedOnEmergencyTitle" msgid="2852916906106191866">"Hitni pozivi su nedostupni"</string>
    <string name="RestrictedOnNormalTitle" msgid="7009474589746551737">"Nema usluge govornih poziva"</string>
    <string name="RestrictedOnAllVoiceTitle" msgid="3982069078579103087">"Nema glasovne usluge ili hitnih poziva"</string>
    <string name="RestrictedStateContent" msgid="7693575344608618926">"Privremeno isključio mobilni operater"</string>
    <string name="RestrictedStateContentMsimTemplate" msgid="5228235722511044687">"Privremeno isključio mobilni operater za SIM <xliff:g id="SIMNUMBER">%d</xliff:g>"</string>
    <string name="NetworkPreferenceSwitchTitle" msgid="1008329951315753038">"Nije moguće dosegnuti mobilnu mrežu"</string>
    <string name="NetworkPreferenceSwitchSummary" msgid="2086506181486324860">"Pokušajte promijeniti preferiranu mrežu. Dodirnite za promjenu."</string>
    <string name="EmergencyCallWarningTitle" msgid="1615688002899152860">"Hitni pozivi su nedostupni"</string>
    <string name="EmergencyCallWarningSummary" msgid="1194185880092805497">"Nije moguće uspostaviti hitne pozive putem Wi‑Fi mreže"</string>
    <string name="notification_channel_network_alert" msgid="4788053066033851841">"Upozorenja"</string>
    <string name="notification_channel_call_forward" msgid="8230490317314272406">"Prosljeđivanje poziva"</string>
    <string name="notification_channel_emergency_callback" msgid="54074839059123159">"Način rada za hitni povratni poziv"</string>
    <string name="notification_channel_mobile_data_status" msgid="1941911162076442474">"Status prijenosa podataka na mobilnoj mreži"</string>
    <string name="notification_channel_sms" msgid="1243384981025535724">"SMS poruke"</string>
    <string name="notification_channel_voice_mail" msgid="8457433203106654172">"Poruke govorne pošte"</string>
    <string name="notification_channel_wfc" msgid="9048240466765169038">"Pozivanje putem WiFi-ja"</string>
    <string name="notification_channel_sim" msgid="5098802350325677490">"Status SIM-a"</string>
    <string name="notification_channel_sim_high_prio" msgid="642361929452850928">"Status visokog prioriteta SIM-a"</string>
    <string name="peerTtyModeFull" msgid="337553730440832160">"Ravnopravni uređaj zatražio načina rada TTY FULL"</string>
    <string name="peerTtyModeHco" msgid="5626377160840915617">"Ravnopravni uređaj zatražio načina rada TTY HCO"</string>
    <string name="peerTtyModeVco" msgid="572208600818270944">"Ravnopravni uređaj zatražio načina rada TTY VCO"</string>
    <string name="peerTtyModeOff" msgid="2420380956369226583">"Ravnopravni uređaj zatražio načina rada TTY OFF"</string>
    <string name="serviceClassVoice" msgid="2065556932043454987">"Govorna"</string>
    <string name="serviceClassData" msgid="4148080018967300248">"Podatke"</string>
    <string name="serviceClassFAX" msgid="2561653371698904118">"Faks"</string>
    <string name="serviceClassSMS" msgid="1547664561704509004">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="2029856900898545984">"Asinhroni"</string>
    <string name="serviceClassDataSync" msgid="7895071363569133704">"Sinhroni"</string>
    <string name="serviceClassPacket" msgid="1430642951399303804">"Paket"</string>
    <string name="serviceClassPAD" msgid="6850244583416306321">"PAD"</string>
    <string name="roamingText0" msgid="7793257871609854208">"Uključen pokazatelj da je uređaj u roamingu"</string>
    <string name="roamingText1" msgid="5073028598334616445">"Isključen pokazatelj da je uređaj u roamingu"</string>
    <string name="roamingText2" msgid="2834048284153110598">"Pokazatelj da je uređaj u roamingu treperi"</string>
    <string name="roamingText3" msgid="831690234035748988">"Izvan naselja"</string>
    <string name="roamingText4" msgid="2171252529065590728">"Izvan zgrade"</string>
    <string name="roamingText5" msgid="4294671587635796641">"Roaming - preferirani sistem"</string>
    <string name="roamingText6" msgid="5536156746637992029">"Roaming - sistem dostupan"</string>
    <string name="roamingText7" msgid="1783303085512907706">"Roaming - udruženi partner"</string>
    <string name="roamingText8" msgid="7774800704373721973">"Roaming - premium partner"</string>
    <string name="roamingText9" msgid="1933460020190244004">"Roaming - sve usluge potpuno dostupne"</string>
    <string name="roamingText10" msgid="7434767033595769499">"Roaming - djelimična funkcionalnost usluga"</string>
    <string name="roamingText11" msgid="5245687407203281407">"Oznaka da je uređaj u roamingu uključena"</string>
    <string name="roamingText12" msgid="673537506362152640">"Oznaka da je uređaj u roamingu ugašena"</string>
    <string name="roamingTextSearching" msgid="5323235489657753486">"Traženje usluge"</string>
    <string name="wfcRegErrorTitle" msgid="3193072971584858020">"Nije moguće postaviti pozivanje putem WiFi-ja"</string>
  <string-array name="wfcOperatorErrorAlertMessages">
    <item msgid="468830943567116703">"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="4795145070505729156">"Došlo je do problema prilikom registracije pozivanja putem WiFi mreže kod vašeg mobilnog operatera: <xliff:g id="CODE">%1$s</xliff:g>"</item>
  </string-array>
    <!-- no translation found for wfcSpnFormat_spn (2982505428519096311) -->
    <skip />
    <string name="wfcSpnFormat_spn_wifi_calling" msgid="3165949348000906194">"<xliff:g id="SPN">%s</xliff:g> Pozivanje putem WiFi-ja"</string>
    <string name="wfcSpnFormat_spn_wifi_calling_vo_hyphen" msgid="3836827895369365298">"<xliff:g id="SPN">%s</xliff:g> Pozivanje putem WiFi-ja"</string>
    <string name="wfcSpnFormat_wlan_call" msgid="4895315549916165700">"WLAN poziv"</string>
    <string name="wfcSpnFormat_spn_wlan_call" msgid="255919245825481510">"<xliff:g id="SPN">%s</xliff:g> WLAN poziv"</string>
    <string name="wfcSpnFormat_spn_wifi" msgid="7232899594327126970">"<xliff:g id="SPN">%s</xliff:g> WiFi"</string>
    <string name="wfcSpnFormat_wifi_calling_bar_spn" msgid="8383917598312067365">"Pozivanje putem WiFi-ja | <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_vowifi" msgid="6865214948822061486">"<xliff:g id="SPN">%s</xliff:g> VoWifi"</string>
    <string name="wfcSpnFormat_wifi_calling" msgid="6178935388378661755">"Pozivanje putem WiFi-ja"</string>
    <string name="wfcSpnFormat_wifi" msgid="1376356951297043426">"WiFi"</string>
    <string name="wfcSpnFormat_wifi_calling_wo_hyphen" msgid="7178561009225028264">"Pozivanje putem WIFi-ja"</string>
    <string name="wfcSpnFormat_vowifi" msgid="8371335230890725606">"VoWifi"</string>
    <string name="wifi_calling_off_summary" msgid="5626710010766902560">"Isključeno"</string>
    <string name="wfc_mode_wifi_preferred_summary" msgid="1035175836270943089">"Poziv putem WiFi-ja"</string>
    <string name="wfc_mode_cellular_preferred_summary" msgid="4958965609212575619">"Poziv putem mobilne mreže"</string>
    <string name="wfc_mode_wifi_only_summary" msgid="104951993894678665">"Samo WiFi"</string>
    <!-- no translation found for crossSimFormat_spn (9125246077491634262) -->
    <skip />
    <string name="crossSimFormat_spn_cross_sim_calling" msgid="5620807020002879057">"<xliff:g id="SPN">%s</xliff:g> – pomoćno pozivanje"</string>
    <string name="cfTemplateNotForwarded" msgid="862202427794270501">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nije proslijeđen"</string>
    <string name="cfTemplateForwarded" msgid="9132506315842157860">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g>"</string>
    <string name="cfTemplateForwardedTime" msgid="735042369233323609">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g> za <xliff:g id="TIME_DELAY">{2}</xliff:g> sekundi"</string>
    <string name="cfTemplateRegistered" msgid="5619930473441550596">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nije proslijeđen"</string>
    <string name="cfTemplateRegisteredTime" msgid="5222794399642525045">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Poziv nije proslijeđen"</string>
    <string name="fcComplete" msgid="1080909484660507044">"Kôd za posebne usluge potpun."</string>
    <string name="fcError" msgid="5325116502080221346">"Problem sa povezivanjem ili nevažeći kôd za posebne usluge."</string>
    <string name="httpErrorOk" msgid="6206751415788256357">"Uredu"</string>
    <string name="httpError" msgid="3406003584150566720">"Došlo je do greške na mreži."</string>
    <string name="httpErrorLookup" msgid="3099834738227549349">"Pronalaženje URL-a nije uspjelo."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="3976195595501606787">"Šema za autentifikaciju stranice nije podržana."</string>
    <string name="httpErrorAuth" msgid="469553140922938968">"Došlo je do greške prilikom autentifikacije."</string>
    <string name="httpErrorProxyAuth" msgid="7229662162030113406">"Došlo je do greške prilikom autentifikacije preko proksi servera."</string>
    <string name="httpErrorConnect" msgid="3295081579893205617">"Povezivanje sa serverom nije uspjelo."</string>
    <string name="httpErrorIO" msgid="3860318696166314490">"Veza sa serverom nije uspostavljena. Pokušajte ponovo kasnije."</string>
    <string name="httpErrorTimeout" msgid="7446272815190334204">"Vrijeme za uspostavljanje veze sa serverom je isteklo."</string>
    <string name="httpErrorRedirectLoop" msgid="8455757777509512098">"Stranica sadrži prevelik broj preusmjeravanja na server."</string>
    <string name="httpErrorUnsupportedScheme" msgid="2664108769858966374">"Protokol nije podržan."</string>
    <string name="httpErrorFailedSslHandshake" msgid="546319061228876290">"Uspostavljanje sigurne veze nije uspjelo."</string>
    <string name="httpErrorBadUrl" msgid="754447723314832538">"Greška pri otvaranju stranice zbog neispravnog URL-a."</string>
    <string name="httpErrorFile" msgid="3400658466057744084">"Pristupanje fajlu nije uspjelo."</string>
    <string name="httpErrorFileNotFound" msgid="5191433324871147386">"Pronalaženje traženog fajla nije uspjelo."</string>
    <string name="httpErrorTooManyRequests" msgid="2149677715552037198">"Trenutno se obrađuje previše zahtjeva. Pokušajte ponovo kasnije."</string>
    <string name="notification_title" msgid="5783748077084481121">"Greška u prijavi za račun <xliff:g id="ACCOUNT">%1$s</xliff:g>"</string>
    <string name="contentServiceSync" msgid="2341041749565687871">"Sinhronizacija"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="5766411446676388623">"Nije moguće sinhronizirati"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="4562226280528716090">"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="5557552311566179924">"Pohrana tableta je puna. Izbrišite fajlove kako biste oslobodili prostor."</string>
    <string name="low_memory" product="watch" msgid="3479447988234030194">"Prostor za gledanje je pun. Izbrišite neke fajlove da oslobodite prostor."</string>
    <string name="low_memory" product="tv" msgid="6663680413790323318">"Pohrana Android TV uređaja je puna. Izbrišite neke fajlove da oslobodite prostor."</string>
    <string name="low_memory" product="default" msgid="2539532364144025569">"Pohrana telefona je puna. Izbrišite fajlove kako biste oslobodili prostor."</string>
    <string name="ssl_ca_cert_warning" msgid="7233573909730048571">"{count,plural, =1{CA certifikat je instaliran}one{CA certifikati su instalirani}few{CA certifikati su instalirani}other{CA certifikati su instalirani}}"</string>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4961102218216815242">"Od nepoznate treće strane"</string>
    <string name="ssl_ca_cert_noti_by_administrator" msgid="4564941950768783879">"Administrator vašeg radnog profila"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="217337232273211674">"Od <xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="work_profile_deleted" msgid="5891181538182009328">"Poslovni profil je obrisan"</string>
    <string name="work_profile_deleted_details" msgid="3773706828364418016">"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="2477244968924647232">"Radni profil više nije dostupan na ovom uređaju"</string>
    <string name="work_profile_deleted_reason_maximum_password_failure" msgid="1080323158315663167">"Previše puta ste pokušali otključati uređaj"</string>
    <string name="device_ownership_relinquished" msgid="4080886992183195724">"Administrator je ustupio uređaj za ličnu upotrebu"</string>
    <string name="network_logging_notification_title" msgid="554983187553845004">"Uređajem se upravlja."</string>
    <string name="network_logging_notification_text" msgid="1327373071132562512">"Vaša organizacija upravlja ovim uređajem i može pratiti mrežni saobraćaj. Dodirnite za detalje."</string>
    <string name="location_changed_notification_title" msgid="3620158742816699316">"Aplikacije mogu pristupiti vašoj lokaciji"</string>
    <string name="location_changed_notification_text" msgid="7158423339982706912">"Za više informacija kontaktirajte IT administratora"</string>
    <string name="geofencing_service" msgid="3826902410740315456">"Usluga geo-ograde"</string>
    <string name="country_detector" msgid="7023275114706088854">"Detektor zemlje"</string>
    <string name="location_service" msgid="2439187616018455546">"Usluga lokacije"</string>
    <string name="gnss_service" msgid="8907781262179951385">"Usluga GNSS"</string>
    <string name="sensor_notification_service" msgid="7474531979178682676">"Usluga obavještavanja putem senzora"</string>
    <string name="twilight_service" msgid="8964898045693187224">"Usluga Twilight"</string>
    <string name="gnss_time_update_service" msgid="9039489496037616095">"GNSS usluga za ažuriranje vremena"</string>
    <string name="device_policy_manager_service" msgid="5085762851388850332">"Usluga upravitelja pravila za uređaje"</string>
    <string name="music_recognition_manager_service" msgid="7481956037950276359">"Usluga upravitelja prepoznavanja muzike"</string>
    <string name="factory_reset_warning" msgid="6858705527798047809">"Uređaj će biti izbrisan"</string>
    <string name="factory_reset_message" msgid="2657049595153992213">"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="3517499806528864633">"Štampanje je onemogućila aplikacija <xliff:g id="OWNER_APP">%s</xliff:g>."</string>
    <string name="personal_apps_suspension_title" msgid="7561416677884286600">"Uključite radni profil"</string>
    <string name="personal_apps_suspension_text" msgid="6115455688932935597">"Vaše lične aplikacije će biti blokirane dok ne uključite radni profil"</string>
    <string name="personal_apps_suspension_soon_text" msgid="8123898693479590">"Lične aplikacije će biti blokirane <xliff:g id="DATE">%1$s</xliff:g> u <xliff:g id="TIME">%2$s</xliff:g>. Vaš IT administrator ne dozvoljava da radni profil bude isključen duže od <xliff:g id="NUMBER">%3$d</xliff:g> dana."</string>
    <string name="personal_apps_suspended_turn_profile_on" msgid="2758012869627513689">"Uključi"</string>
    <string name="me" msgid="6207584824693813140">"Ja"</string>
    <string name="power_dialog" product="tablet" msgid="8333207765671417261">"Opcije tableta"</string>
    <string name="power_dialog" product="tv" msgid="7792839006640933763">"Opcije Android TV uređaja"</string>
    <string name="power_dialog" product="default" msgid="1107775420270203046">"Opcije telefona"</string>
    <string name="silent_mode" msgid="8796112363642579333">"Nečujni način rada"</string>
    <string name="turn_on_radio" msgid="2961717788170634233">"Uključi bežičnu vezu"</string>
    <string name="turn_off_radio" msgid="7222573978109933360">"Isključi bežičnu vezu"</string>
    <string name="screen_lock" msgid="2072642720826409809">"Zaključavanje ekrana"</string>
    <string name="power_off" msgid="4111692782492232778">"Isključi"</string>
    <string name="silent_mode_silent" msgid="5079789070221150912">"Zvuk zvona isključen"</string>
    <string name="silent_mode_vibrate" msgid="8821830448369552678">"Zvuk zvona na vibraciji"</string>
    <string name="silent_mode_ring" msgid="6039011004781526678">"Zvuk zvona uključen"</string>
    <string name="reboot_to_update_title" msgid="2125818841916373708">"Ažuriranje sistema Android"</string>
    <string name="reboot_to_update_prepare" msgid="6978842143587422365">"Priprema za ažuriranje..."</string>
    <string name="reboot_to_update_package" msgid="4644104795527534811">"Obrađuje se paket ažuriranja..."</string>
    <string name="reboot_to_update_reboot" msgid="4474726009984452312">"Ponovno pokretanje......"</string>
    <string name="reboot_to_reset_title" msgid="2226229680017882787">"Vraćanje na fabričke postavke"</string>
    <string name="reboot_to_reset_message" msgid="3347690497972074356">"Ponovno pokretanje......"</string>
    <string name="shutdown_progress" msgid="5017145516412657345">"Isključivanje...…"</string>
    <string name="shutdown_confirm" product="tablet" msgid="2872769463279602432">"Vaš tablet će se isključiti."</string>
    <string name="shutdown_confirm" product="tv" msgid="7975942887313518330">"Vaš Android TV uređaj će se isključiti."</string>
    <string name="shutdown_confirm" product="watch" msgid="2977299851200240146">"Sat će se isključiti."</string>
    <string name="shutdown_confirm" product="default" msgid="136816458966692315">"Telefon će se isključiti."</string>
    <string name="shutdown_confirm_question" msgid="796151167261608447">"Želite li ugasiti telefon?"</string>
    <string name="reboot_safemode_title" msgid="5853949122655346734">"Ponovo pokreni uređaj u sigurnom načinu rada"</string>
    <string name="reboot_safemode_confirm" msgid="1658357874737219624">"Ž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="8183172372995396653">"Nedavni zadaci"</string>
    <string name="no_recent_tasks" msgid="9063946524312275906">"Nema nedavno pokrenutih aplikacija."</string>
    <string name="global_actions" product="tablet" msgid="4412132498517933867">"Opcije tableta"</string>
    <string name="global_actions" product="tv" msgid="3871763739487450369">"Opcije Android TV uređaja"</string>
    <string name="global_actions" product="default" msgid="6410072189971495460">"Opcije telefona"</string>
    <string name="global_action_lock" msgid="6949357274257655383">"Zaključavanje ekrana"</string>
    <string name="global_action_power_off" msgid="4404936470711393203">"Isključi"</string>
    <string name="global_action_power_options" msgid="1185286119330160073">"Napajanje"</string>
    <string name="global_action_restart" msgid="4678451019561687074">"Ponovo pokreni"</string>
    <string name="global_action_emergency" msgid="1387617624177105088">"Hitno"</string>
    <string name="global_action_bug_report" msgid="5127867163044170003">"Izvještaj o greškama"</string>
    <string name="global_action_logout" msgid="6093581310002476511">"Završi sesiju"</string>
    <string name="global_action_screenshot" msgid="2610053466156478564">"Snimak ekrana"</string>
    <string name="bugreport_title" msgid="8549990811777373050">"Izvještaj o greškama"</string>
    <string name="bugreport_message" msgid="5212529146119624326">"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="7968287837902871289">"Interaktivni izvještaj"</string>
    <string name="bugreport_option_interactive_summary" msgid="8493795476325339542">"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="7681035745950045690">"Kompletan izvještaj"</string>
    <string name="bugreport_option_full_summary" msgid="1975130009258435885">"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>
    <string name="bugreport_countdown" msgid="6418620521782120755">"{count,plural, =1{Snimanje ekrana za izvještaj o grešci za # s.}one{Snimanje ekrana za izvještaj o grešci za # s.}few{Snimanje ekrana za izvještaj o grešci za # s.}other{Snimanje ekrana za izvještaj o grešci za # s.}}"</string>
    <string name="bugreport_screenshot_success_toast" msgid="7986095104151473745">"Napravljen je snimak ekrana s izvještajem o grešci"</string>
    <string name="bugreport_screenshot_failure_toast" msgid="6736320861311294294">"Snimanje ekrana s izvještajem o grešci nije uspjelo"</string>
    <string name="global_action_toggle_silent_mode" msgid="8464352592860372188">"Nečujni način rada"</string>
    <string name="global_action_silent_mode_on_status" msgid="2371892537738632013">"Zvuk je isključen"</string>
    <string name="global_action_silent_mode_off_status" msgid="6608006545950920042">"Zvuk je uključen"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="6911684460146916206">"Način rada u avionu"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="5508025516695361936">"Uključen je način rada u avionu"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="8522219771500505475">"Način rada u avionu ugašen"</string>
    <string name="global_action_settings" msgid="4671878836947494217">"Postavke"</string>
    <string name="global_action_assist" msgid="2517047220311505805">"Pomoć"</string>
    <string name="global_action_voice_assist" msgid="6655788068555086695">"Glasovna pomoć"</string>
    <string name="global_action_lockdown" msgid="2475471405907902963">"Zaključavanje"</string>
    <string name="status_bar_notification_info_overflow" msgid="3330152558746563475">"999+"</string>
    <string name="notification_hidden_text" msgid="2835519769868187223">"Novo obavještenje"</string>
    <string name="notification_channel_virtual_keyboard" msgid="6465975799223304567">"Virtuelna tastatura"</string>
    <string name="notification_channel_physical_keyboard" msgid="5417306456125988096">"Fizička tastatura"</string>
    <string name="notification_channel_security" msgid="8516754650348238057">"Sigurnost"</string>
    <string name="notification_channel_car_mode" msgid="2123919247040988436">"Način rada u automobilu"</string>
    <string name="notification_channel_account" msgid="6436294521740148173">"Status računa"</string>
    <string name="notification_channel_developer" msgid="1691059964407549150">"Poruke za programere"</string>
    <string name="notification_channel_developer_important" msgid="7197281908918789589">"Važne poruke za programere"</string>
    <string name="notification_channel_updates" msgid="7907863984825495278">"Ažuriranja"</string>
    <string name="notification_channel_network_status" msgid="2127687368725272809">"Status mreže"</string>
    <string name="notification_channel_network_alerts" msgid="6312366315654526528">"Mrežna upozorenja"</string>
    <string name="notification_channel_network_available" msgid="6083697929214165169">"Mreža je dostupna"</string>
    <string name="notification_channel_vpn" msgid="1628529026203808999">"Status VPN-a"</string>
    <string name="notification_channel_device_admin" msgid="6384932669406095506">"Upozorenja od IT administratora"</string>
    <string name="notification_channel_alerts" msgid="5070241039583668427">"Upozorenja"</string>
    <string name="notification_channel_retail_mode" msgid="3732239154256431213">"Prodajna demonstracija"</string>
    <string name="notification_channel_usb" msgid="1528280969406244896">"USB veza"</string>
    <string name="notification_channel_heavy_weight_app" msgid="17455756500828043">"Pokrenuta aplikacija"</string>
    <string name="notification_channel_foreground_service" msgid="7102189948158885178">"Aplikacije koje troše bateriju"</string>
    <string name="notification_channel_accessibility_magnification" msgid="1707913872219798098">"Uvećavanje"</string>
    <string name="notification_channel_accessibility_security_policy" msgid="1727787021725251912">"Korištenje pristupačnosti"</string>
    <string name="foreground_service_app_in_background" msgid="1439289699671273555">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> troši bateriju"</string>
    <string name="foreground_service_apps_in_background" msgid="7340037176412387863">"Broj aplikacija koje troše bateriju: <xliff:g id="NUMBER">%1$d</xliff:g>"</string>
    <string name="foreground_service_tap_for_details" msgid="9078123626015586751">"Dodirnite za detalje o potrošnji baterije i prijenosa podataka"</string>
    <string name="foreground_service_multiple_separator" msgid="5002287361849863168">"<xliff:g id="LEFT_SIDE">%1$s</xliff:g>, <xliff:g id="RIGHT_SIDE">%2$s</xliff:g>"</string>
    <string name="safeMode" msgid="8974401416068943888">"Siguran način rada"</string>
    <string name="android_system_label" msgid="5974767339591067210">"Sistem Android"</string>
    <string name="user_owner_label" msgid="8628726904184471211">"Pređite na lični profil"</string>
    <string name="managed_profile_label" msgid="7316778766973512382">"Pređite na radni profil"</string>
    <string name="permgrouplab_contacts" msgid="4254143639307316920">"Kontakti"</string>
    <string name="permgroupdesc_contacts" msgid="9163927941244182567">"pristupa vašim kontaktima"</string>
    <string name="permgrouplab_location" msgid="1858277002233964394">"Lokacija"</string>
    <string name="permgroupdesc_location" msgid="1995955142118450685">"pristupa lokaciji ovog uređaja"</string>
    <string name="permgrouplab_calendar" msgid="6426860926123033230">"Kalendar"</string>
    <string name="permgroupdesc_calendar" msgid="6762751063361489379">"pristupa vašem kalendaru"</string>
    <string name="permgrouplab_sms" msgid="795737735126084874">"SMS"</string>
    <string name="permgroupdesc_sms" msgid="5726462398070064542">"šalje i pregleda SMS poruke"</string>
    <string name="permgrouplab_storage" msgid="17339216290379241">"Fajlovi"</string>
    <string name="permgroupdesc_storage" msgid="5378659041354582769">"pristup fajlovima na vašem uređaju"</string>
    <string name="permgrouplab_readMediaAural" msgid="1858331312624942053">"Muzika i audio"</string>
    <string name="permgroupdesc_readMediaAural" msgid="7565467343667089595">"pristupanje muzici i zvuku na vašem uređaju"</string>
    <string name="permgrouplab_readMediaVisual" msgid="4724874717811908660">"Fotografije i videozapisi"</string>
    <string name="permgroupdesc_readMediaVisual" msgid="4080463241903508688">"pristupanje fotografijama i videozapisima na vašem uređaju"</string>
    <string name="permgrouplab_microphone" msgid="2480597427667420076">"Mikrofon"</string>
    <string name="permgroupdesc_microphone" msgid="1047786732792487722">"snima zvuk"</string>
    <string name="permgrouplab_activityRecognition" msgid="3324466667921775766">"Fizička aktivnost"</string>
    <string name="permgroupdesc_activityRecognition" msgid="4725624819457670704">"pristup vašoj fizičkoj aktivnosti"</string>
    <string name="permgrouplab_camera" msgid="9090413408963547706">"Kamera"</string>
    <string name="permgroupdesc_camera" msgid="7585150538459320326">"snima fotografije i videozapise"</string>
    <string name="permgrouplab_nearby_devices" msgid="5529147543651181991">"Uređaji u blizini"</string>
    <string name="permgroupdesc_nearby_devices" msgid="3213561597116913508">"otkrivanje uređaja u blizini i povezivanje s njima"</string>
    <string name="permgrouplab_calllog" msgid="7926834372073550288">"Zapisnici poziva"</string>
    <string name="permgroupdesc_calllog" msgid="2026996642917801803">"čitanje i pisanje zapisnika telefonskih poziva"</string>
    <string name="permgrouplab_phone" msgid="570318944091926620">"Telefon"</string>
    <string name="permgroupdesc_phone" msgid="270048070781478204">"poziva i upravlja pozivima"</string>
    <string name="permgrouplab_sensors" msgid="9134046949784064495">"Tjelesni senzori"</string>
    <string name="permgroupdesc_sensors" msgid="2610631290633747752">"pristupa podacima senzora o vašim vitalnim funkcijama"</string>
    <string name="permgrouplab_notifications" msgid="5472972361980668884">"Obavještenja"</string>
    <string name="permgroupdesc_notifications" msgid="4608679556801506580">"prikaz obavještenja"</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="7554282892101587296">"preuzima sadržaj prozora"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="6195610527625237661">"Pregleda sadržaj prozora koji trenutno koristite."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="327598364696316213">"uključi opciju Istraživanje dodirom"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="4394677060796752976">"Stavke koje dodirnete bit će izgovorene naglas, a ekran možete istraživati koristeći pokrete."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2772371671541753254">"prati tekst koji unosite"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="2381315802405773092">"Obuhvata lične podatke kao što su brojevi kreditnih kartica i lozinke."</string>
    <string name="capability_title_canControlMagnification" msgid="7701572187333415795">"kontrolira uvećavanje prikaza na ekranu"</string>
    <string name="capability_desc_canControlMagnification" msgid="2206586716709254805">"Kontrolira stepen uvećanja prikaza na ekranu i podešavanje položaja."</string>
    <string name="capability_title_canPerformGestures" msgid="9106545062106728987">"izvodi pokrete"</string>
    <string name="capability_desc_canPerformGestures" msgid="6619457251067929726">"Može dodirivati, prevlačiti, hvatati prstima i praviti druge pokrete."</string>
    <string name="capability_title_canCaptureFingerprintGestures" msgid="1189053104594608091">"prepoznaje pokrete za otisak prsta"</string>
    <string name="capability_desc_canCaptureFingerprintGestures" msgid="6861869337457461274">"Moguće je zabilježiti pokrete na senzoru za otisak prsta uređaja."</string>
    <string name="capability_title_canTakeScreenshot" msgid="3895812893130071930">"pravi snimke ekrana"</string>
    <string name="capability_desc_canTakeScreenshot" msgid="7762297374317934052">"Moguće je snimiti ekran."</string>
    <string name="permlab_statusBar" msgid="8798267849526214017">"onemogućavanje ili mijenjanje statusne trake"</string>
    <string name="permdesc_statusBar" msgid="5809162768651019642">"Dozvoljava aplikaciji onemogućavanje statusne trake ili dodavanje i uklanjanje sistemskih ikona."</string>
    <string name="permlab_statusBarService" msgid="2523421018081437981">"funkcioniranje u vidu statusne trake"</string>
    <string name="permdesc_statusBarService" msgid="6652917399085712557">"Dozvoljava aplikaciji da postane statusna traka."</string>
    <string name="permlab_expandStatusBar" msgid="1184232794782141698">"proširivanje/sužavanje statusne trake"</string>
    <string name="permdesc_expandStatusBar" msgid="7180756900448498536">"Dozvoljava aplikaciji proširivanje ili sužavanje statusne trake."</string>
    <string name="permlab_fullScreenIntent" msgid="4310888199502509104">"prikaz obavještenja kao aktivnosti preko cijelog ekrana na zaključanom uređaju"</string>
    <string name="permdesc_fullScreenIntent" msgid="1100721419406643997">"Dozvoljava aplikaciji da prikazuje obavještenja kao aktivnosti preko cijelog ekrana na zaključanom uređaju"</string>
    <string name="permlab_install_shortcut" msgid="7451554307502256221">"Instaliranje prečica"</string>
    <string name="permdesc_install_shortcut" msgid="4476328467240212503">"Omogućava aplikaciji dodavanje prečice za početni ekran bez intervencije korisnika."</string>
    <string name="permlab_uninstall_shortcut" msgid="295263654781900390">"uklanjanje prečica"</string>
    <string name="permdesc_uninstall_shortcut" msgid="1924735350988629188">"Omogućava aplikaciji uklanjanje prečice početnog ekrana bez intervencije korisnika."</string>
    <string name="permlab_processOutgoingCalls" msgid="4075056020714266558">"preusmjeravanje odlaznih poziva"</string>
    <string name="permdesc_processOutgoingCalls" msgid="7833149750590606334">"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="4131324833663725855">"odgovor na telefonski poziv"</string>
    <string name="permdesc_answerPhoneCalls" msgid="894386681983116838">"Omogućava aplikaciji odgovor na dolazni telefonski poziv."</string>
    <string name="permlab_receiveSms" msgid="505961632050451881">"primanje tekstualnih poruka (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="1797345626687832285">"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="4000650116674380275">"primanje tekstualnih poruka (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="958102423732219710">"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_bindCellBroadcastService" msgid="586746677002040651">"Prosljeđivanje poruka info servisa"</string>
    <string name="permdesc_bindCellBroadcastService" msgid="6540910200973641606">"Dopušta aplikaciji da se veže za modul info servisa kako bi prosljeđivala poruke info servisa. 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 informacije o vanrednoj situaciji od info servisa."</string>
    <string name="permlab_manageOngoingCalls" msgid="281244770664231782">"Upravljanje pozivima u toku"</string>
    <string name="permdesc_manageOngoingCalls" msgid="7003138133829915265">"Omogućava aplikaciji da vidi detalje o pozivima u toku na vašem uređaju i da ih kontrolira."</string>
    <string name="permlab_readCellBroadcasts" msgid="5869884450872137693">"čitanje poruka info servisa"</string>
    <string name="permdesc_readCellBroadcasts" msgid="672513437331980168">"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="217624769238425461">"čitanje sadržaja na koje ste pretplaćeni"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="6911349196661811865">"Dozvoljava aplikaciji prikupljanje detalja o trenutno sinhroniziranim sadržajima."</string>
    <string name="permlab_sendSms" msgid="7757368721742014252">"slanje i pregledanje SMS poruka"</string>
    <string name="permdesc_sendSms" msgid="6757089798435130769">"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="5164176626258800297">"čitanje vaših tekstualnih poruka (SMS ili MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="7912990447198112829">"Ova aplikacija može čitati sve SMS (tekstualne) poruke pohranjene na vašem tabletu."</string>
    <string name="permdesc_readSms" product="tv" msgid="3054753345758011986">"Ova aplikacija može čitati sve SMS (tekstualne) poruke koje su pohranjene na vašem Android TV uređaju."</string>
    <string name="permdesc_readSms" product="default" msgid="774753371111699782">"Ova aplikacija može čitati sve SMS (tekstualne) poruke pohranjene na vašem telefonu."</string>
    <string name="permlab_receiveWapPush" msgid="4223747702856929056">"primanje tekstualnih poruka (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="1638677888301778457">"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="7460048811831750262">"preuzimanje informacija o pokrenutim aplikacijama"</string>
    <string name="permdesc_getTasks" msgid="7388138607018233726">"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="639849495253987493">"upravljanje vlasnicima profila i uređaja"</string>
    <string name="permdesc_manageProfileAndDeviceOwners" msgid="7304240671781989283">"Omogućava aplikaciji da postavi vlasnike profila i vlasnika uređaja."</string>
    <string name="permlab_reorderTasks" msgid="7598562301992923804">"izmjena rasporeda pokrenutih aplikacija"</string>
    <string name="permdesc_reorderTasks" msgid="8796089937352344183">"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="893019409519325311">"omogućavanje načina rada u autu"</string>
    <string name="permdesc_enableCarMode" msgid="56419168820473508">"Dozvoljava aplikaciji da omogući način rada u autu."</string>
    <string name="permlab_killBackgroundProcesses" msgid="6559320515561928348">"zatvaranje drugih aplikacija"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="2357013583055434685">"Omogućava aplikaciji prekid pozadinskih procesa drugih aplikacija. Ovo može dovesti do prestanka rada drugih aplikacija."</string>
    <string name="permlab_systemAlertWindow" msgid="5757218350944719065">"Ova aplikacija se može pojaviti iznad drugih aplikacija"</string>
    <string name="permdesc_systemAlertWindow" msgid="1145660714855738308">"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="541863968571682785">"rad u pozadini"</string>
    <string name="permdesc_runInBackground" msgid="4344539472115495141">"Ova aplikacija može raditi u pozadini. To može brže istrošiti bateriju."</string>
    <string name="permlab_useDataInBackground" msgid="783415807623038947">"prijenos podataka u pozadini"</string>
    <string name="permdesc_useDataInBackground" msgid="1230753883865891987">"Ova aplikacija može prenositi podatke u pozadini. To može povećati prijenos podataka."</string>
    <string name="permlab_persistentActivity" msgid="464970041740567970">"podešavanje aplikacije tako da je uvijek pokrenuta"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="6055271149187369916">"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="6800526387664131321">"Omogućava aplikaciji da neke svoje dijelove trajno pohrani u memoriji. To može ograničiti veličinu raspoložive memorije za druge aplikacije i na taj način usporiti telefon."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="1914841924366562051">"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="1768855976818467491">"pokretanje usluge u prvom planu"</string>
    <string name="permdesc_foregroundService" msgid="8720071450020922795">"Dopušta aplikaciji korištenje usluga u prvom planu."</string>
    <string name="permlab_getPackageSize" msgid="375391550792886641">"mjerenje prostora kojeg aplikacije zauzimaju u pohrani"</string>
    <string name="permdesc_getPackageSize" msgid="742743530909966782">"Dozvoljava aplikaciji preuzimanje svog koda, podataka i veličine keš memorije"</string>
    <string name="permlab_writeSettings" msgid="8057285063719277394">"izmjena postavki sistema"</string>
    <string name="permdesc_writeSettings" msgid="8293047411196067188">"Dozvoljava aplikaciji izmijenu postavki sistema. Zlonamjerne aplikacije mogu oštetiti konfiguraciju sistema."</string>
    <string name="permlab_receiveBootCompleted" msgid="6643339400247325379">"pokrenuti pri pokretanju"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="5565659082718177484">"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="4900842256047614307">"Omogućava aplikaciji da se sama pokrene čim sistem završi pokretanje. Pokretanje Android TV uređaja zbog toga može trajati duže i na taj način se može omogućiti aplikaciji da svojim neprekidnim radom uspori rad čitavog uređaja."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="7912677044558690092">"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="4552241916400572230">"slanje ljepljivih informacija"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="5058486069846384013">"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="2338185920171000650">"Omogućava aplikaciji slanje ljepljivih informacija koje ostaju nakon prestanka emitiranja. Pretjeranom upotrebom može se usporiti ili destabilizirati rad Android TV uređaja zbog korištenja previše memorije."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="134529339678913453">"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="8776395111787429099">"čitanje vaših kontakata"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="6430093481659992692">"Dozvoljava aplikaciji da čita podatke o kontaktima pohranjenim na tabletu. Aplikacije će također imati pristup računima na tabletu koji su kreirali kontakte. Ovo može uključivati račune koje su kreirale aplikacije koje ste instalirali. Ovo odobrenje dozvoljava aplikacijama da sačuvaju podatke o kontaktima, a zlonamjerne aplikacije mogu dijeliti te podatke bez vašeg znanja."</string>
    <string name="permdesc_readContacts" product="tv" msgid="8400138591135554789">"Dozvoljava aplikaciji da čita podatke o kontaktima pohranjenim na Android TV uređaju. Aplikacije će također imati pristup računima na Android TV uređaju koji su kreirali kontakte. Ovo može uključivati račune koje su kreirale aplikacije koje ste instalirali. Ovo odobrenje dozvoljava aplikacijama da sačuvaju podatke o kontaktima, a zlonamjerne aplikacije mogu dijeliti te podatke bez vašeg znanja."</string>
    <string name="permdesc_readContacts" product="default" msgid="4911989776203207644">"Dozvoljava aplikaciji da čita podatke o kontaktima pohranjenim na telefonu. Aplikacije će također imati pristup računima na telefonu koji su kreirali kontakte. Ovo može uključivati račune koje su kreirale aplikacije koje ste instalirali. Ovo odobrenje dozvoljava aplikacijama da sačuvaju podatke o kontaktima, a zlonamjerne aplikacije mogu dijeliti te podatke bez vašeg znanja."</string>
    <string name="permlab_writeContacts" msgid="8919430536404830430">"izmjena podataka o kontaktima"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="6422419281427826181">"Dozvoljava aplikaciji da vrši izmjene podataka o kontaktima pohranjenim na tabletu. Ovo odobrenje dozvoljava aplikacijama da izbrišu podatke o kontaktima."</string>
    <string name="permdesc_writeContacts" product="tv" msgid="6488872735379978935">"Dozvoljava aplikaciji da vrši izmjene podataka o kontaktima pohranjenim na Android TV uređaju. Ovo odobrenje dozvoljava aplikacijama da izbrišu podatke o kontaktima."</string>
    <string name="permdesc_writeContacts" product="default" msgid="8304795696237065281">"Dozvoljava aplikaciji da vrši izmjene podataka o kontaktima pohranjenim na telefonu. Ovo odobrenje dozvoljava aplikacijama da izbrišu podatke o kontaktima."</string>
    <string name="permlab_readCallLog" msgid="1739990210293505948">"čitanje zapisnika poziva"</string>
    <string name="permdesc_readCallLog" msgid="8964770895425873433">"Ova aplikacija može čitati historiju vaših poziva."</string>
    <string name="permlab_writeCallLog" msgid="670292975137658895">"pisanje zapisnika poziva"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="2657525794731690397">"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="3934939195095317432">"Omogućava aplikaciji izmjenu zapisnika poziva Android TV uređaja, uključujući podatke o dolaznim i odlaznim pozivima. Zlonamjerne aplikacije to mogu iskoristiti za brisanje ili izmjenu zapisnika poziva."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="5903033505665134802">"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="662918578601619569">"Pristup podacima tjelesnih senzora, kao što je puls, dok se koristi"</string>
    <string name="permdesc_bodySensors" product="default" msgid="7652650410295512140">"Dozvoljava aplikaciji dok se koristi da pristupa podacima tjelesnih senzora kao što su puls, temperatura i postotak kisika u krvi."</string>
    <string name="permlab_bodySensors_background" msgid="4912560779957760446">"Pristup podacima tjelesnih senzora, kao što je puls, dok je u pozadini"</string>
    <string name="permdesc_bodySensors_background" product="default" msgid="8870726027557749417">"Dozvoljava aplikaciji dok je u pozadini da pristupa podacima tjelesnih senzora kao što su puls, temperatura i postotak kisika u krvi."</string>
    <string name="permlab_readCalendar" msgid="6408654259475396200">"Čitanje događaja kalendara i detalja"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="515452384059803326">"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="5811726712981647628">"Ova aplikacija može čitati sve događaje u kalendaru na vašem Android TV uređaju i dijeliti ili sačuvati podatke kalendara."</string>
    <string name="permdesc_readCalendar" product="default" msgid="9118823807655829957">"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="6422137308329578076">"dodavanje ili izmjena kalendarskih događaja i slanje e-pošte gostima bez znanja vlasnika"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="8722230940717092850">"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="951246749004952706">"Ova aplikacija može dodavati, uklanjati ili mijenjati događaje u kalendaru na vašem Android TV uređaju. Aplikacija može slati poruke koje mogu izgledati kao da dolaze od vlasnika kalendara ili promijeniti događaje bez obavještenja vlasnika."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="5416380074475634233">"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="5162339812057983988">"pristup dodatnim informacijama o lokaciji"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="355369611979907967">"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="6426318438195622966">"pristup tačnoj lokaciji samo u prvom planu"</string>
    <string name="permdesc_accessFineLocation" msgid="6732174080240016335">"Ova aplikacija može odrediti vašu tačnu lokaciju iz usluga lokacije dok se aplikacija koristi. Da aplikacija odredi lokaciju, usluge lokacije moraju biti uključene na uređaju. Ovim se može povećati potrošnja baterija."</string>
    <string name="permlab_accessCoarseLocation" msgid="1561042925407799741">"pristup približnoj lokaciji samo u prvom planu"</string>
    <string name="permdesc_accessCoarseLocation" msgid="778521847873199160">"Ova aplikacija može odrediti vašu približnu lokaciju iz usluga lokacije dok se aplikacija koristi. Da aplikacija odredi lokaciju, usluge lokacije moraju biti uključene na uređaju."</string>
    <string name="permlab_accessBackgroundLocation" msgid="1721164702777366138">"pristup lokaciji u pozadini"</string>
    <string name="permdesc_accessBackgroundLocation" msgid="8264885066095638105">"Ova aplikacija može pristupiti lokaciji bilo kada, čak i kada se aplikacija ne koristi."</string>
    <string name="permlab_modifyAudioSettings" msgid="6129039778010031815">"izmjene postavki zvuka"</string>
    <string name="permdesc_modifyAudioSettings" msgid="8687227609663124921">"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="1208457423054219147">"snimanje audiozapisa"</string>
    <string name="permdesc_recordAudio" msgid="5857246765327514062">"Za vrijeme korištenja, ova aplikacija može snimati zvuk koristeći mikrofon."</string>
    <string name="permlab_recordBackgroundAudio" msgid="5891032812308878254">"snimanje zvuka u pozadini"</string>
    <string name="permdesc_recordBackgroundAudio" msgid="1992623135737407516">"Ova aplikacija može u svakom trenutku snimati zvuk koristeći mikrofon."</string>
    <string name="permlab_sim_communication" msgid="176788115994050692">"slanje komandi SIM kartici"</string>
    <string name="permdesc_sim_communication" msgid="4179799296415957960">"Omogućava aplikaciji slanje naredbi na SIM. Ovo je vrlo opasno."</string>
    <string name="permlab_activityRecognition" msgid="1782303296053990884">"prepoznavanje fizičke aktivnosti"</string>
    <string name="permdesc_activityRecognition" msgid="8667484762991357519">"Ova aplikacija može prepoznati vašu fizičku aktivnost."</string>
    <string name="permlab_camera" msgid="6320282492904119413">"snimanje slika i videozapisa"</string>
    <string name="permdesc_camera" msgid="5240801376168647151">"Za vrijeme korištenja, ova aplikacija može snimati slike i videozapise koristeći kameru."</string>
    <string name="permlab_backgroundCamera" msgid="7549917926079731681">"snimanje slika i videozapisa u pozadini"</string>
    <string name="permdesc_backgroundCamera" msgid="1615291686191138250">"Ova aplikacija može snimati slike i videozapise koristeći kameru bilo kada."</string>
    <string name="permlab_systemCamera" msgid="3642917457796210580">"Dopustite aplikaciji ili usluzi da pristupa kamerama sistema radi snimanja fotografija i videozapisa"</string>
    <string name="permdesc_systemCamera" msgid="5938360914419175986">"Ova povlaštena ili sistemska aplikacija u svakom trenutku može snimati fotografije i videozapise pomoću kamere sistema. Aplikacija također mora imati odobrenje android.permission.CAMERA"</string>
    <string name="permlab_cameraOpenCloseListener" msgid="5548732769068109315">"Dozvoliti aplikaciji ili usluzi da prima povratne pozive o otvaranju ili zatvaranju kamera."</string>
    <string name="permdesc_cameraOpenCloseListener" msgid="2002636131008772908">"Ova aplikacija može primati povratne pozive kada se otvara ili zatvara bilo koji uređaj s kamerom (putem neke aplikacije)."</string>
    <string name="permlab_vibrate" msgid="8596800035791962017">"kontrola vibracije"</string>
    <string name="permdesc_vibrate" msgid="8733343234582083721">"Dozvoljava aplikaciji upravljanje vibracijom."</string>
    <string name="permdesc_vibrator_state" msgid="7050024956594170724">"Dozvoljava aplikaciji pristup stanju vibracije."</string>
    <string name="permlab_callPhone" msgid="1798582257194643320">"izravno zvanje telefonskih brojeva"</string>
    <string name="permdesc_callPhone" msgid="5439809516131609109">"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="442192920714863782">"pristup usluzi IMS pozivanja"</string>
    <string name="permdesc_accessImsCallService" msgid="6328551241649687162">"Omogućava aplikaciji da koristi IMS uslugu za pozivanje bez vaše intervencije."</string>
    <string name="permlab_readPhoneState" msgid="8138526903259297969">"čitanje statusa i identiteta telefona"</string>
    <string name="permdesc_readPhoneState" msgid="7229063553502788058">"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_readBasicPhoneState" msgid="3214853233263871347">"očitavanje osnovnog telefonskog statusa i identiteta"</string>
    <string name="permdesc_readBasicPhoneState" msgid="828185691675460520">"Dozvoljava aplikaciji pristup osnovnim telefonskim funkcijama uređaja."</string>
    <string name="permlab_manageOwnCalls" msgid="9033349060307561370">"usmjeravanje poziva preko sistema"</string>
    <string name="permdesc_manageOwnCalls" msgid="4431178362202142574">"Dopušta aplikaciji da pozive usmjeri preko sistema radi poboljšanja iskustva pozivanja."</string>
    <string name="permlab_callCompanionApp" msgid="3654373653014126884">"vidjeti i kontrolirati pozive preko sistema."</string>
    <string name="permdesc_callCompanionApp" msgid="8474168926184156261">"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_exemptFromAudioRecordRestrictions" msgid="1164725468350759486">"oslobađanje od ograničenja snimanja zvuka"</string>
    <string name="permdesc_exemptFromAudioRecordRestrictions" msgid="2425117015896871976">"Oslobodite aplikaciju od ograničenja snimаnja zvuka."</string>
    <string name="permlab_acceptHandover" msgid="2925523073573116523">"nastavlja poziv iz druge aplikacije"</string>
    <string name="permdesc_acceptHandovers" msgid="7129026180128626870">"Dozvoljava aplikaciji nastavljanje poziva koji je započet u drugoj aplikaciji."</string>
    <string name="permlab_readPhoneNumbers" msgid="5668704794723365628">"čitanje telefonskih brojeva"</string>
    <string name="permdesc_readPhoneNumbers" msgid="7368652482818338871">"Dozvoljava aplikaciji pristup telefonskim brojevima uređaja."</string>
    <string name="permlab_wakeLock" product="automotive" msgid="1904736682319375676">"ostavi ekran automobila uključenim"</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1527660973931694000">"sprečavanje tableta da uđe u režim mirovanja"</string>
    <string name="permlab_wakeLock" product="tv" msgid="2856941418123343518">"sprečavanje stupanja Android TV uređaja u stanje mirovanja"</string>
    <string name="permlab_wakeLock" product="default" msgid="569409726861695115">"sprečavanje telefona da uđe u režim mirovanja"</string>
    <string name="permdesc_wakeLock" product="automotive" msgid="5995045369683254571">"Dozvoljava aplikaciji da ostavi ekran automobila uključenim."</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="2441742939101526277">"Dozvoljava aplikaciji da spriječi tablet da ode u stanje mirovanja."</string>
    <string name="permdesc_wakeLock" product="tv" msgid="2329298966735118796">"Omogućava aplikaciji da spriječi stupanje Android TV uređaja u stanje mirovanja."</string>
    <string name="permdesc_wakeLock" product="default" msgid="3689523792074007163">"Dozvoljava aplikaciji da spriječi telefon da ode u stanje mirovanja."</string>
    <string name="permlab_transmitIr" msgid="8077196086358004010">"prijenos putem infracrvenog odašiljača"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5884738958581810253">"Omogućava aplikaciji korištenje infracrvenog odašiljača tableta."</string>
    <string name="permdesc_transmitIr" product="tv" msgid="3278506969529173281">"Omogućava aplikaciji da koristi infracrveni predajnik Android TV uređaja."</string>
    <string name="permdesc_transmitIr" product="default" msgid="8484193849295581808">"Omogućava aplikaciji korištenje infracrvenog odašiljača telefona."</string>
    <string name="permlab_setWallpaper" msgid="6959514622698794511">"postavljanje pozadinske slike"</string>
    <string name="permdesc_setWallpaper" msgid="2973996714129021397">"Dozvoljava aplikaciji postavljanje sistemske pozadinske slike."</string>
    <string name="permlab_setWallpaperHints" msgid="1153485176642032714">"prilagođavanje veličine pozadinske slike"</string>
    <string name="permdesc_setWallpaperHints" msgid="6257053376990044668">"Dozvoljava aplikaciji određivanje veličine sistemske pozadinske slike."</string>
    <string name="permlab_setTimeZone" msgid="7922618798611542432">"postavljanje vremenske zone"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1788868809638682503">"Dozvoljava aplikaciji promjenu vremenske zone tableta."</string>
    <string name="permdesc_setTimeZone" product="tv" msgid="9069045914174455938">"Omogućava aplikaciji da izmijeni vremensku zonu vašeg Android TV uređaja."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4611828585759488256">"Dozvoljava aplikaciji promjenu vremenske zone telefona."</string>
    <string name="permlab_getAccounts" msgid="5304317160463582791">"pronalaženje računa na uređaju"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="1784452755887604512">"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="437604680436540822">"Omogućava aplikaciji da preuzme listu računa koje vaš Android TV uređaj poznaje. To može obuhvatiti sve račune koji su kreirani pomoću aplikacija koje ste instalirali."</string>
    <string name="permdesc_getAccounts" product="default" msgid="2491273043569751867">"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="2349126720783633918">"prikaz mrežnih veza"</string>
    <string name="permdesc_accessNetworkState" msgid="4394564702881662849">"Omogućava aplikaciji pregled informacija o mrežnim vezama, npr. koje mreže postoje i koje su povezane."</string>
    <string name="permlab_createNetworkSockets" msgid="3224420491603590541">"ima potpuni pristup mreži"</string>
    <string name="permdesc_createNetworkSockets" msgid="7722020828749535988">"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="8945711637530425586">"izmjene povezivanja na mrežu"</string>
    <string name="permdesc_changeNetworkState" msgid="649341947816898736">"Dozvoljava aplikaciji izmjenu stanja mrežne povezanosti."</string>
    <string name="permlab_changeTetherState" msgid="9079611809931863861">"izmjene podijeljenog povezivanja"</string>
    <string name="permdesc_changeTetherState" msgid="3025129606422533085">"Dozvoljava aplikaciji izmjenu stanja povezanosti na podijeljenu mrežu."</string>
    <string name="permlab_accessWifiState" msgid="5552488500317911052">"pregled WiFi veza"</string>
    <string name="permdesc_accessWifiState" msgid="6913641669259483363">"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="7947824109713181554">"uspostavljanje i prekidanje WiFi veze"</string>
    <string name="permdesc_changeWifiState" msgid="7170350070554505384">"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="285626875870754696">"dozvoljava prijem paketa kroz WiFi Multicast"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="191079868596433554">"Omogućava aplikaciji prijem paketa poslanih svim uređajima na WiFi mreži pomoću višesmjernih adresa, 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="1336952358450652595">"Omogućava aplikaciji prijem paketa poslanih svim uređajima na WiFi mreži pomoću višesmjernih adresa, a ne samo na vaš Android TV uređaj. Na ovaj način se troši više energije nego u načinu bez višesmjernog slanja."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="8296627590220222740">"Omogućava aplikaciji prijem paketa poslanih svim uređajima na WiFi mreži pomoću višesmjernih adresa, a ne samo na vaš telefon. Troši više energije nego rad van multicast načina rada."</string>
    <string name="permlab_bluetoothAdmin" msgid="6490373569441946064">"pristup Bluetooth postavkama"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="5370837055438574863">"Dozvoljava aplikaciji konfiguriranje lokalnog Bluetooth tableta te otkrivanje udaljenih uređaja i sparivanje s njima."</string>
    <string name="permdesc_bluetoothAdmin" product="tv" msgid="1623992984547014588">"Omogućava aplikaciji da konfigurira Bluetooth na vašem Android TV uređaju te da otkrije i upari udaljene uređaje."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="7381341743021234863">"Dozvoljava aplikaciji konfiguriranje lokalnog Bluetooth telefona te otkrivanje udaljenih uređaja i sparivanje s njima."</string>
    <string name="permlab_accessWimaxState" msgid="7029563339012437434">"uspostavljanje i prekidanje veze sa WiMAX mrežama"</string>
    <string name="permdesc_accessWimaxState" msgid="5372734776802067708">"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="6223305780806267462">"izmjene stanja WiMAX signala"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="4011097664859480108">"Omogućava aplikaciji uspostavljanje i prekidanje veze tableta sa WiMAX mrežama."</string>
    <string name="permdesc_changeWimaxState" product="tv" msgid="5373274458799425276">"Omogućava aplikaciji da se poveže s vašim Android TV uređajem i prekine povezanost Android TV uređaja s WiMAX mrežama."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="1551666203780202101">"Omogućava aplikaciji uspostavljanje i prekidanje veze telefona sa WiMAX mrežama."</string>
    <string name="permlab_bluetooth" msgid="586333280736937209">"uparivanje s Bluetooth uređajima"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3053222571491402635">"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="8851534496561034998">"Omogućava aplikaciji da prikaže konfiguraciju Bluetootha na Android TV uređaju te uspostavi i prihvati vezu s uparenim uređajima."</string>
    <string name="permdesc_bluetooth" product="default" msgid="2779606714091276746">"Omogućava aplikaciji prikaz konfiguracije za Bluetooth na telefonu, kao i uspostavljanje i prihvatanje veza sa uparenim uređajima."</string>
    <string name="permlab_bluetooth_scan" msgid="5402587142833124594">"otkrivanje i upariv. s Bluetooth uređajima u blizini"</string>
    <string name="permdesc_bluetooth_scan" product="default" msgid="6540723536925289276">"Dozvoljava aplikaciji da otkrije Bluetooth uređaje u blizini i upari se s njima"</string>
    <string name="permlab_bluetooth_connect" msgid="6657463246355003528">"povezivanje s uparenim Bluetooth uređajima"</string>
    <string name="permdesc_bluetooth_connect" product="default" msgid="4546016548795544617">"Dozvoljava aplikaciji da se poveže s uparenim Bluetooth uređajima"</string>
    <string name="permlab_bluetooth_advertise" msgid="2781147747928853177">"oglašavanje na Bluetooth uređajima u blizini"</string>
    <string name="permdesc_bluetooth_advertise" product="default" msgid="6085174451034210183">"Dozvoljava aplikaciji da vrši oglašavanje na Bluetooth uređajima u blizini"</string>
    <string name="permlab_uwb_ranging" msgid="8141915781475770665">"određivanje rel. položaja uređaja ultra širokog opsega u blizini"</string>
    <string name="permdesc_uwb_ranging" msgid="2519723069604307055">"Dozvolite aplikaciji da odredi relativni položaj između uređaja ultra širokog opsega u blizini"</string>
    <string name="permlab_nearby_wifi_devices" msgid="392774237063608500">"stupanje u interakciju s WiFi uređajima u blizini"</string>
    <string name="permdesc_nearby_wifi_devices" msgid="3054307728646332906">"Dozvoljava aplikaciji da se oglašava, povezuje i određuje relativni položaj WiFi uređaja u blizini"</string>
    <string name="permlab_preferredPaymentInfo" msgid="5274423844767445054">"Informacije o preferiranoj usluzi plaćanja putem NFC-a"</string>
    <string name="permdesc_preferredPaymentInfo" msgid="8583552469807294967">"Dozvoljava aplikaciji da dobije informacije o preferiranoj usluzi plaćanja putem NFC-a kao što su registrirana pomagala i odredište rute."</string>
    <string name="permlab_nfc" msgid="1904455246837674977">"upravljanje NFC-om"</string>
    <string name="permdesc_nfc" msgid="8352737680695296741">"Dozvoljava aplikaciji komuniciranje sa NFC (komunikacija bliskog polja) oznakama, karticama i čitačima."</string>
    <string name="permlab_disableKeyguard" msgid="3605253559020928505">"deaktivacija zaključavanja ekrana"</string>
    <string name="permdesc_disableKeyguard" msgid="3223710003098573038">"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="1808977190557794109">"zahtjev za kompleksnost zaključavanja ekrana"</string>
    <string name="permdesc_requestPasswordComplexity" msgid="1130556896836258567">"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_postNotification" msgid="4875401198597803658">"prikaz obavještenja"</string>
    <string name="permdesc_postNotification" msgid="5974977162462877075">"Dozvoljava aplikaciji da prikazuje obavještenja"</string>
    <string name="permlab_useBiometric" msgid="6314741124749633786">"koristi biometrijski hardver za otiske prstij"</string>
    <string name="permdesc_useBiometric" msgid="7502858732677143410">"Omogućava aplikaciji da za autentifikaciju koristi biometrijski hardver"</string>
    <string name="permlab_manageFingerprint" msgid="7432667156322821178">"upravljanje hardverom za otisak prsta"</string>
    <string name="permdesc_manageFingerprint" msgid="2025616816437339865">"Omogućava aplikaciji da koristi metode za dodavanje i brisanje šablona otisaka prstiju za upotrebu."</string>
    <string name="permlab_useFingerprint" msgid="1001421069766751922">"korištenje hardvera za otisak prsta"</string>
    <string name="permdesc_useFingerprint" msgid="412463055059323742">"Omogućava aplikaciji da za autentifikaciju koristi hardver za otisak prsta"</string>
    <string name="permlab_audioWrite" msgid="8501705294265669405">"izmjena muzičke kolekcije"</string>
    <string name="permdesc_audioWrite" msgid="8057399517013412431">"Omogućava aplikaciji da mijenja vašu muzičku kolekciju."</string>
    <string name="permlab_videoWrite" msgid="5940738769586451318">"izmjena kolekcije videozapisa"</string>
    <string name="permdesc_videoWrite" msgid="6124731210613317051">"Omogućava aplikaciji da mijenja vašu kolekciju videozapisa."</string>
    <string name="permlab_imagesWrite" msgid="1774555086984985578">"izmjena kolekcije fotografija"</string>
    <string name="permdesc_imagesWrite" msgid="5195054463269193317">"Omogućava aplikaciji da mijenja vašu kolekciju fotografija."</string>
    <string name="permlab_mediaLocation" msgid="7368098373378598066">"čitanje lokacija iz kolekcije medija"</string>
    <string name="permdesc_mediaLocation" msgid="597912899423578138">"Omogućava aplikaciji da čita lokacije iz vaše kolekcije medija."</string>
    <string name="biometric_app_setting_name" msgid="3339209978734534457">"Koristi biometriju"</string>
    <string name="biometric_or_screen_lock_app_setting_name" msgid="5348462421758257752">"Koristi biometriju ili zaključavanje ekrana"</string>
    <string name="biometric_dialog_default_title" msgid="55026799173208210">"Potvrdite identitet"</string>
    <string name="biometric_dialog_default_subtitle" msgid="8457232339298571992">"Koristite biometriju da nastavite"</string>
    <string name="biometric_or_screen_lock_dialog_default_subtitle" msgid="159539678371552009">"Koristite biometriju ili zaključavanje ekrana da nastavite"</string>
    <string name="biometric_error_hw_unavailable" msgid="2494077380540615216">"Biometrijski hardver nije dostupan"</string>
    <string name="biometric_error_user_canceled" msgid="6732303949695293730">"Autentifikacija je otkazana"</string>
    <string name="biometric_not_recognized" msgid="5106687642694635888">"Nije prepoznato"</string>
    <string name="biometric_error_canceled" msgid="8266582404844179778">"Autentifikacija je otkazana"</string>
    <string name="biometric_error_device_not_secured" msgid="3129845065043995924">"Nije postavljen PIN, uzorak niti lozinka"</string>
    <string name="biometric_error_generic" msgid="6784371929985434439">"Greška pri autentifikaciji"</string>
    <string name="screen_lock_app_setting_name" msgid="6054944352976789228">"Koristi zaključavanje ekrana"</string>
    <string name="screen_lock_dialog_default_subtitle" msgid="120359538048533695">"Unesite zaključavanje ekrana da nastavite"</string>
    <string name="fingerprint_acquired_partial" msgid="4323789264604479684">"Čvrsto pritisnite senzor"</string>
    <!-- no translation found for fingerprint_acquired_insufficient (623888149088216458) -->
    <skip />
    <string name="fingerprint_acquired_imager_dirty" msgid="1770676120848224250">"Očistite senzor za otisak prsta i pokušajte ponovo"</string>
    <string name="fingerprint_acquired_imager_dirty_alt" msgid="9169582140486372897">"Očistite senzor i pokušajte ponovo"</string>
    <string name="fingerprint_acquired_too_fast" msgid="1628459767349116104">"Čvrsto pritisnite senzor"</string>
    <string name="fingerprint_acquired_too_slow" msgid="6683510291554497580">"Presporo ste pomjerili prst. Pokušajte ponovo."</string>
    <string name="fingerprint_acquired_already_enrolled" msgid="2285166003936206785">"Pokušajte s drugim otiskom prsta"</string>
    <string name="fingerprint_acquired_too_bright" msgid="3863560181670915607">"Presvijetlo"</string>
    <!-- no translation found for fingerprint_acquired_power_press (3107864151278434961) -->
    <skip />
    <string name="fingerprint_acquired_try_adjusting" msgid="3667006071003809364">"Pokušajte podesiti"</string>
    <string name="fingerprint_acquired_immobile" msgid="1621891895241888048">"Svaki put pomalo promijenite položaj prsta"</string>
  <string-array name="fingerprint_acquired_vendor">
  </string-array>
    <string name="fingerprint_error_not_match" msgid="4599441812893438961">"Otisak prsta nije prepoznat"</string>
    <string name="fingerprint_udfps_error_not_match" msgid="8236930793223158856">"Otisak prsta nije prepoznat"</string>
    <string name="fingerprint_authenticated" msgid="2024862866860283100">"Otisak prsta je potvrđen"</string>
    <string name="face_authenticated_no_confirmation_required" msgid="8867889115112348167">"Lice je provjereno"</string>
    <string name="face_authenticated_confirmation_required" msgid="6872632732508013755">"Lice je provjereno, pritisnite dugme za potvrdu"</string>
    <string name="fingerprint_error_hw_not_available" msgid="4571700896929561202">"Hardver za otisak prsta nije dostupan."</string>
    <string name="fingerprint_error_no_space" msgid="7285481581905967580">"Nije moguće postaviti otisak prsta"</string>
    <!-- no translation found for fingerprint_error_timeout (7361192266621252164) -->
    <skip />
    <string name="fingerprint_error_canceled" msgid="540026881380070750">"Radnja s otiskom prsta je otkazana."</string>
    <string name="fingerprint_error_user_canceled" msgid="7685676229281231614">"Korisnik je otkazao radnju s otiskom prsta."</string>
    <!-- no translation found for fingerprint_error_lockout (6626753679019351368) -->
    <skip />
    <string name="fingerprint_error_lockout_permanent" msgid="9060651300306264843">"Previše pokušaja. Umjesto toga koristite zaključavanje ekrana."</string>
    <!-- no translation found for fingerprint_error_unable_to_process (2446280592818621224) -->
    <skip />
    <string name="fingerprint_error_no_fingerprints" msgid="8671811719699072411">"Nije prijavljen nijedan otisak prsta."</string>
    <string name="fingerprint_error_hw_not_present" msgid="578914350967423382">"Ovaj uređaj nema senzor za otisak prsta."</string>
    <string name="fingerprint_error_security_update_required" msgid="7750187320640856433">"Senzor je privremeno onemogućen."</string>
    <string name="fingerprint_error_bad_calibration" msgid="4385512597740168120">"Nije moguće koristiti senzor za otisak prsta. Posjetite pružaoca usluga za popravke"</string>
    <string name="fingerprint_error_power_pressed" msgid="5479524500542129414">"Dugme za uključivanje je pritisnuto"</string>
    <string name="fingerprint_name_template" msgid="8941662088160289778">"Prst <xliff:g id="FINGERID">%d</xliff:g>"</string>
    <string name="fingerprint_app_setting_name" msgid="4253767877095495844">"Koristi otisak prsta"</string>
    <string name="fingerprint_or_screen_lock_app_setting_name" msgid="3501743523487644907">"Koristi otisak prsta ili zaključavanje ekrana"</string>
    <string name="fingerprint_dialog_default_subtitle" msgid="3879832845486835905">"Nastavite pomoću otiska prsta"</string>
    <string name="fingerprint_or_screen_lock_dialog_default_subtitle" msgid="5195808203117992200">"Koristite otisak prsta ili zaključavanje ekrana da nastavite"</string>
  <string-array name="fingerprint_error_vendor">
  </string-array>
    <string name="fingerprint_error_vendor_unknown" msgid="4170002184907291065">"Nešto nije uredu. Pokušajte ponovo."</string>
    <string name="fingerprint_icon_content_description" msgid="4741068463175388817">"Ikona za otisak prsta"</string>
    <string name="face_recalibrate_notification_name" msgid="7311163114750748686">"Otključavanje licem"</string>
    <string name="face_recalibrate_notification_title" msgid="2524791952735579082">"Problem s otključavanjem licem"</string>
    <string name="face_recalibrate_notification_content" msgid="3064513770251355594">"Dodirnite da izbrišete model lica, a zatim ponovo dodajte lice"</string>
    <string name="face_setup_notification_title" msgid="8843461561970741790">"Postavite otključavanje licem"</string>
    <string name="face_setup_notification_content" msgid="5463999831057751676">"Otključajte telefon gledajući u njega"</string>
    <string name="face_sensor_privacy_enabled" msgid="7407126963510598508">"Da koristite otključavanje licem, uključite "<b>"Pristup kameri"</b>" u meniju Postavke &gt; Privatnost"</string>
    <string name="fingerprint_setup_notification_title" msgid="2002630611398849495">"Postavite više načina otključavanja"</string>
    <string name="fingerprint_setup_notification_content" msgid="205578121848324852">"Dodirnite da dodate otisak prsta"</string>
    <string name="fingerprint_recalibrate_notification_name" msgid="1414578431898579354">"Otključavanje otiskom prsta"</string>
    <string name="fingerprint_recalibrate_notification_title" msgid="2406561052064558497">"Nije moguće koristiti senzor za otisak prsta"</string>
    <string name="fingerprint_recalibrate_notification_content" msgid="8519935717822194943">"Posjetite pružaoca usluga za popravke."</string>
    <string name="face_acquired_insufficient" msgid="6889245852748492218">"Nije moguće kreirati model lica. Pokušajte ponovo."</string>
    <string name="face_acquired_too_bright" msgid="8070756048978079164">"Previše svijetlo. Probajte s blažim osvjetljenjem."</string>
    <string name="face_acquired_too_dark" msgid="8539853432479385326">"Nema dovoljno svjetla"</string>
    <string name="face_acquired_too_close" msgid="4453646176196302462">"Odmaknite telefon"</string>
    <string name="face_acquired_too_far" msgid="2922278214231064859">"Primaknite telefon"</string>
    <string name="face_acquired_too_high" msgid="8278815780046368576">"Pomjerite telefon naviše"</string>
    <string name="face_acquired_too_low" msgid="4075391872960840081">"Pomjerite telefon naniže"</string>
    <string name="face_acquired_too_right" msgid="6245286514593540859">"Pomjerite telefon ulijevo"</string>
    <string name="face_acquired_too_left" msgid="9201762240918405486">"Pomjerite telefon udesno"</string>
    <string name="face_acquired_poor_gaze" msgid="4427153558773628020">"Gledajte direktno u uređaj."</string>
    <string name="face_acquired_not_detected" msgid="1057966913397548150">"Ne vidi se lice. Držite telefon u visini očiju."</string>
    <string name="face_acquired_too_much_motion" msgid="8199691445085189528">"Previše pokreta. Držite telefon mirno."</string>
    <string name="face_acquired_recalibrate" msgid="8724013080976469746">"Ponovo registrirajte lice."</string>
    <string name="face_acquired_too_different" msgid="2520389515612972889">"Nije moguće prepoznati lice. Pokušajte ponovo."</string>
    <string name="face_acquired_too_similar" msgid="8882920552674125694">"Malo pomjerite glavu"</string>
    <string name="face_acquired_pan_too_extreme" msgid="5417928604710621088">"Gledajte direktno u telefon"</string>
    <string name="face_acquired_tilt_too_extreme" msgid="5715715666540716620">"Gledajte direktno u telefon"</string>
    <string name="face_acquired_roll_too_extreme" msgid="8261939882838881194">"Gledajte direktno u telefon"</string>
    <string name="face_acquired_obscured" msgid="4917643294953326639">"Uklonite sve što vam zaklanja lice."</string>
    <string name="face_acquired_sensor_dirty" msgid="8968391891086721678">"Očistite vrh ekrana, uključujući crnu traku"</string>
    <!-- no translation found for face_acquired_dark_glasses_detected (5643703296620631986) -->
    <skip />
    <!-- no translation found for face_acquired_mouth_covering_detected (8219428572168642593) -->
    <skip />
    <string name="face_acquired_recalibrate_alt" msgid="5702674220280332115">"Nije moguće kreirati model lica. Pokušajte ponovo."</string>
    <string name="face_acquired_dark_glasses_detected_alt" msgid="4052123776406041972">"Otkrivene su tamne naočale. Lice se mora u potpunosti vidjeti."</string>
    <string name="face_acquired_mouth_covering_detected_alt" msgid="1122294982850589766">"Otkriveno je pokrivalo preko lica. Lice se mora u potpunosti vidjeti."</string>
  <string-array name="face_acquired_vendor">
  </string-array>
    <string name="face_error_hw_not_available" msgid="5085202213036026288">"Nije moguće potvrditi lice. Hardver nije dostupan."</string>
    <string name="face_error_timeout" msgid="2598544068593889762">"Pokušajte ponovo s otključavanjem licem"</string>
    <string name="face_error_no_space" msgid="5649264057026021723">"Nije moguće sačuvati nove podatke o licu. Prvo izbrišite stare."</string>
    <string name="face_error_canceled" msgid="2164434737103802131">"Prepoznavanje lica je otkazano."</string>
    <string name="face_error_user_canceled" msgid="5766472033202928373">"Korisnik je otkazao otključavanje licem"</string>
    <string name="face_error_lockout" msgid="7864408714994529437">"Previše pokušaja. Pokušajte ponovo kasnije."</string>
    <string name="face_error_lockout_permanent" msgid="3277134834042995260">"Previše pokušaja. Otključavanje licem je onemogućeno."</string>
    <string name="face_error_lockout_screen_lock" msgid="5062609811636860928">"Previše pokušaja. Umjesto toga unesite zaključavanje ekrana."</string>
    <string name="face_error_unable_to_process" msgid="5723292697366130070">"Nije moguće potvrditi lice. Pokušajte ponovo."</string>
    <string name="face_error_not_enrolled" msgid="1134739108536328412">"Niste postavili otključavanje licem"</string>
    <string name="face_error_hw_not_present" msgid="7940978724978763011">"Otključavanje licem nije podržano na ovom uređaju"</string>
    <string name="face_error_security_update_required" msgid="5076017208528750161">"Senzor je privremeno onemogućen."</string>
    <string name="face_name_template" msgid="3877037340223318119">"Lice <xliff:g id="FACEID">%d</xliff:g>"</string>
    <string name="face_app_setting_name" msgid="5854024256907828015">"Koristi otključavanje licem"</string>
    <string name="face_or_screen_lock_app_setting_name" msgid="1603149075605709106">"Koristi otključavanje licem ili zaključavanje ekrana"</string>
    <string name="face_dialog_default_subtitle" msgid="6620492813371195429">"Koristite lice da nastavite"</string>
    <string name="face_or_screen_lock_dialog_default_subtitle" msgid="5006381531158341844">"Koristite lice ili zaključavanje ekrana da nastavite"</string>
  <string-array name="face_error_vendor">
  </string-array>
    <string name="face_error_vendor_unknown" msgid="7387005932083302070">"Nešto nije uredu. Pokušajte ponovo."</string>
    <string name="face_icon_content_description" msgid="465030547475916280">"Ikona lica"</string>
    <string name="permlab_readSyncSettings" msgid="6250532864893156277">"čitanje postavki za sinhroniziranje"</string>
    <string name="permdesc_readSyncSettings" msgid="1325658466358779298">"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="6583154300780427399">"aktiviranje/deaktiviranje sinhroniziranja"</string>
    <string name="permdesc_writeSyncSettings" msgid="6029151549667182687">"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="3747407238320105332">"čitanje statistike sinhroniziranja"</string>
    <string name="permdesc_readSyncStats" msgid="3867809926567379434">"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="5791467020950064920">"čita sadržaj vaše dijeljene pohrane"</string>
    <string name="permdesc_sdcardRead" msgid="6872973242228240382">"Omogućava aplikaciji čitanje sadržaja vaše dijeljenje pohrane."</string>
    <string name="permlab_readMediaAudio" msgid="8723513075731763810">"čitanje audio fajlova iz dijeljene pohrane"</string>
    <string name="permdesc_readMediaAudio" msgid="5299772574434619399">"Omogućava aplikaciji da čita audio fajlove iz vaše dijeljene pohrane."</string>
    <string name="permlab_readMediaVideo" msgid="7768003311260655007">"čitanje fajlova videozapisa iz dijeljene pohrane"</string>
    <string name="permdesc_readMediaVideo" msgid="3846400073770403528">"Omogućava aplikaciji da čita fajlove videozapisa iz vaše dijeljene pohrane."</string>
    <string name="permlab_readMediaImages" msgid="4057590631020986789">"čitanje fajlova slika iz dijeljene pohrane"</string>
    <string name="permdesc_readMediaImages" msgid="5836219373138469259">"Omogućava aplikaciji da čita fajlove slika iz vaše dijeljene pohrane."</string>
    <string name="permlab_sdcardWrite" msgid="4863021819671416668">"mijenja ili briše sadržaj vaše dijeljene pohrane"</string>
    <string name="permdesc_sdcardWrite" msgid="8376047679331387102">"Omogućava aplikaciji da piše sadržaj vaše dijeljene pohrane."</string>
    <string name="permlab_use_sip" msgid="8250774565189337477">"Uputi/primi SIP pozive"</string>
    <string name="permdesc_use_sip" msgid="3590270893253204451">"Dozvoljava aplikaciji upućivanje i primanje SIP poziva."</string>
    <string name="permlab_register_sim_subscription" msgid="1653054249287576161">"registriraj nove telekom SMS veze"</string>
    <string name="permdesc_register_sim_subscription" msgid="4183858662792232464">"Dozvoljava aplikaciji da registrira nove telekom SIM veze."</string>
    <string name="permlab_register_call_provider" msgid="6135073566140050702">"registriraj nove telekom veze"</string>
    <string name="permdesc_register_call_provider" msgid="4201429251459068613">"Dozvoljava aplikaciji da registrira nove telekom veze."</string>
    <string name="permlab_connection_manager" msgid="3179365584691166915">"upravljaj telekom vezama"</string>
    <string name="permdesc_connection_manager" msgid="1426093604238937733">"Dozvoljava aplikacijama upravljanje telekom vezama."</string>
    <string name="permlab_bind_incall_service" msgid="5990625112603493016">"vrši interakciju s ekranom tokom poziva"</string>
    <string name="permdesc_bind_incall_service" msgid="4124917526967765162">"Dozvoljava aplikaciji da kontrolira kada i kako korisnik vidi ekran tokom poziva."</string>
    <string name="permlab_bind_connection_service" msgid="5409268245525024736">"vrši interakciju s telefonskim uslugama"</string>
    <string name="permdesc_bind_connection_service" msgid="6261796725253264518">"Dozvoljava aplikaciji interakciju s telefonskim uslugama za upućivanje/prijem poziva."</string>
    <string name="permlab_control_incall_experience" msgid="6436863486094352987">"omogući opcije tokom poziva"</string>
    <string name="permdesc_control_incall_experience" msgid="5896723643771737534">"Dozvoljava aplikaciji da omogući opcije tokom poziva."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="8470402862501573795">"čitanje historije korištenja mreže"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="1112962304941637102">"Dozvoljava aplikaciji da pročita istoriju korištenja mreže za određene mreže i aplikacije."</string>
    <string name="permlab_manageNetworkPolicy" msgid="6872549423152175378">"upravljanje mrežnim pravilima"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="1865663268764673296">"Dozvoljava aplikaciji upravljanje mrežnim pravilima i određivanje pravila koja se odnose na aplikacije."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="7448790834938749041">"izmjena obračunavanja korištenja mreže"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5076042642247205390">"Dozvoljava aplikaciji izmjenu načina na koji aplikacije koriste mreže. Nije namijenjeno za uobičajene aplikacije."</string>
    <string name="permlab_accessNotifications" msgid="7130360248191984741">"pristup obavještenjima"</string>
    <string name="permdesc_accessNotifications" msgid="761730149268789668">"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="5848096702733262458">"povezivanje sa uslugom za slušanje obavještenja"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="4970553694467137126">"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="5245421224814878483">"poveži sa servisom pružaoca uslova"</string>
    <string name="permdesc_bindConditionProviderService" msgid="6106018791256120258">"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="4776175992848982706">"poveži sa servisom za čuvanje ekrana"</string>
    <string name="permdesc_bindDreamService" msgid="9129615743300572973">"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="5098810760209818140">"pokretanje operaterove aplikacije za konfiguraciju"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4790845896063237887">"Omogućava vlasniku pokretanje aplikacije za konfiguraciju koju je obezbijedio operater. Nije potrebno za normalne aplikacije."</string>
    <string name="permlab_accessNetworkConditions" msgid="1270732533356286514">"slušanje informacija o stanju mreže"</string>
    <string name="permdesc_accessNetworkConditions" msgid="2959269186741956109">"Omogućava aplikaciji slušanje informacije o stanju mreže. Nije potrebno za obične aplikacije."</string>
    <string name="permlab_setInputCalibration" msgid="932069700285223434">"promijeni kalibraciju ulaznog uređaja"</string>
    <string name="permdesc_setInputCalibration" msgid="2937872391426631726">"Dozvoljava aplikaciji kalibriranje parametara dodirnog ekrana. Nije potrebno za obične aplikacije."</string>
    <string name="permlab_accessDrmCertificates" msgid="6473765454472436597">"pristupi DRM certifikatima"</string>
    <string name="permdesc_accessDrmCertificates" msgid="6983139753493781941">"Dozvoljava aplikaciji da obezbijedi i koristi DRM certifikate. Nije potrebno za obične aplikacije."</string>
    <string name="permlab_handoverStatus" msgid="7620438488137057281">"prijem statusa prebacivanja preko Android prebacivanja"</string>
    <string name="permdesc_handoverStatus" msgid="3842269451732571070">"Dozvoljava aplikaciji prijem informacija o trenutnim prijenosima putem funkcije Android Beam"</string>
    <string name="permlab_removeDrmCertificates" msgid="710576248717404416">"ukloni DRM certifikate"</string>
    <string name="permdesc_removeDrmCertificates" msgid="4068445390318355716">"Dozvoljava aplikaciji da ukloni DRM certifikate. Nije potrebno za obične aplikacije."</string>
    <string name="permlab_bindCarrierMessagingService" msgid="3363450860593096967">"poveži sa servisom za poruke operatera"</string>
    <string name="permdesc_bindCarrierMessagingService" msgid="6316457028173478345">"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="2395596978626237474">"povezivanje na usluge operatera"</string>
    <string name="permdesc_bindCarrierServices" msgid="9185614481967262900">"Omogućava vlasniku povezivanje sa uslugama operatera. Obično nije potrebno za obične aplikacije."</string>
    <string name="permlab_access_notification_policy" msgid="5524112842876975537">"pristup načinu rada Ne ometaj"</string>
    <string name="permdesc_access_notification_policy" msgid="8538374112403845013">"Omogućava aplikaciji da čita i upisuje konfiguraciju načina rada Ne ometaj."</string>
    <string name="permlab_startViewPermissionUsage" msgid="1504564328641112341">"pokrenuti korištenje odobrenja za pregled"</string>
    <string name="permdesc_startViewPermissionUsage" msgid="2820325605959586538">"Dozvoljava vlasniku da pokrene korištenje odobrenja za aplikaciju. Ne bi trebalo biti potrebno za obične aplikacije."</string>
    <string name="permlab_startReviewPermissionDecisions" msgid="8690578688476599284">"prikažite odluke o odobrenjima"</string>
    <string name="permdesc_startReviewPermissionDecisions" msgid="2775556853503004236">"Dozvoljava vlasniku da pokrene ekran radi pregleda odluka o odobrenju. Obično nije potrebno za obične aplikacije."</string>
    <string name="permlab_startViewAppFeatures" msgid="7955084203185903001">"pokretanje pregleda funkcija aplikacije"</string>
    <string name="permdesc_startViewAppFeatures" msgid="7207240860165206107">"Dozvoljava vlasniku da pokrene pregled informacija o funkcijama za aplikaciju."</string>
    <string name="permlab_highSamplingRateSensors" msgid="3941068435726317070">"pristup podacima senzora velikom brzinom uzorkovanja"</string>
    <string name="permdesc_highSamplingRateSensors" msgid="8430061978931155995">"Dozvoljava aplikaciji da uzorkuje podatke senzora brzinom većom od 200 Hz"</string>
    <string name="policylab_limitPassword" msgid="4851829918814422199">"Postavljanje pravila za lozinke"</string>
    <string name="policydesc_limitPassword" msgid="4105491021115793793">"Kontrolira dužinu i znakove koji su dozvoljeni u lozinkama za zaključavanje ekrana i PIN-ovima."</string>
    <string name="policylab_watchLogin" msgid="7599669460083719504">"Prati pokušaje otključavanja ekrana"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="2388436408621909298">"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="2140588224468517507">"Praćenje broja unosa netačnih lozinki pri otključavanju ekrana i zaključavanje Android TV uređaja ili brisanje svih podataka Android TV uređaja u slučaju prevelikog broja unosa netačnih lozinki."</string>
    <string name="policydesc_watchLogin" product="automotive" msgid="7011438994051251521">"Prati koliko puta je lozinka neispravno unijeta prilikom otključavanja ekrana i zaključava informativno-zabavni sistem ili briše sve podatke informativno-zabavnog sistema ako se lozinka neispravno unese previše puta."</string>
    <string name="policydesc_watchLogin" product="default" msgid="4885030206253600299">"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="2049038943004297474">"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="8965224107449407052">"Praćenje broja unosa netačnih lozinki za otključavanje ekrana te zaključavanje Android TV uređaja ili brisanje svih podataka ovog korisnika u slučaju prekomjernog unosa netačnih lozinki."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="automotive" msgid="7180857406058327941">"Prati koliko puta je lozinka neispravno unijeta prilikom otključavanja ekrana i zaključava informativno-zabavni sistem ili briše sve podatke ovog profila ako se lozinka neispravno unese previše puta."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="default" msgid="9177645136475155924">"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="214556238645096520">"Promjena zaključavanja ekrana"</string>
    <string name="policydesc_resetPassword" msgid="4626419138439341851">"Mijenja zaključavanje ekrana."</string>
    <string name="policylab_forceLock" msgid="7360335502968476434">"Zaključavanje ekrana"</string>
    <string name="policydesc_forceLock" msgid="1008844760853899693">"Kontrolira kako i kada se ekran zaključava."</string>
    <string name="policylab_wipeData" msgid="1359485247727537311">"Brisanje svih podataka"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="7245372676261947507">"Briše podatke s tableta bez upozorenja tako što ga vraća na fabričke postavke."</string>
    <string name="policydesc_wipeData" product="tv" msgid="513862488950801261">"Brisanje podataka Android TV uređaja bez upozorenja vraćanjem uređaja na fabričke postavke."</string>
    <string name="policydesc_wipeData" product="automotive" msgid="660804547737323300">"Bez upozorenja briše podatke informativno-zabavnog sistema vraćanjem na fabričke postavke."</string>
    <string name="policydesc_wipeData" product="default" msgid="8036084184768379022">"Briše podatke s telefona bez upozorenja vraćanjem telefona na fabričke postavke."</string>
    <string name="policylab_wipeData_secondaryUser" product="automotive" msgid="115034358520328373">"Briše podatke profila"</string>
    <string name="policylab_wipeData_secondaryUser" product="default" msgid="413813645323433166">"Izbriši podatke korisnika"</string>
    <string name="policydesc_wipeData_secondaryUser" product="tablet" msgid="2336676480090926470">"Bez upozorenja briše podatke ovog korisnika sa ovog tableta."</string>
    <string name="policydesc_wipeData_secondaryUser" product="tv" msgid="2293713284515865200">"Brisanje podataka ovog korisnika na Android TV uređaju bez upozorenja."</string>
    <string name="policydesc_wipeData_secondaryUser" product="automotive" msgid="4658832487305780879">"Bez upozorenja briše podatke ovog profila na ovom informativno-zabavnom sistemu."</string>
    <string name="policydesc_wipeData_secondaryUser" product="default" msgid="2788325512167208654">"Bez upozorenja briše podatke ovog korisnika sa ovog telefona."</string>
    <string name="policylab_setGlobalProxy" msgid="215332221188670221">"Postavlja globalni proksi uređaja"</string>
    <string name="policydesc_setGlobalProxy" msgid="7149665222705519604">"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="6015404400532459169">"Postavi isteknuće lozinke za zaključavanje ekrana"</string>
    <string name="policydesc_expirePassword" msgid="9136524319325960675">"Mijenja koliko često se lozinka za zaključavanje ekrana, PIN ili obrazac moraju promijeniti."</string>
    <string name="policylab_encryptedStorage" msgid="9012936958126670110">"Podešava šifriranje pohrane"</string>
    <string name="policydesc_encryptedStorage" msgid="1102516950740375617">"Zahtijeva šifriranje pohranjenih podataka aplikacije."</string>
    <string name="policylab_disableCamera" msgid="5749486347810162018">"Isključuje kamere"</string>
    <string name="policydesc_disableCamera" msgid="3204405908799676104">"Sprečava korištenje svih kamera uređaja."</string>
    <string name="policylab_disableKeyguardFeatures" msgid="5071855750149949741">"Onemog. funkcija zaklj. ekrana"</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="6641673177041195957">"Sprečava korištenje nekih funkcija za zaključavanje ekrana."</string>
  <string-array name="phoneTypes">
    <item msgid="8996339953292723951">"Kuća"</item>
    <item msgid="7740243458912727194">"Mobilni"</item>
    <item msgid="8526146065496663766">"Posao"</item>
    <item msgid="8150904584178569699">"Poslovni faks"</item>
    <item msgid="4537253139152229577">"Kućni faks"</item>
    <item msgid="6751245029698664340">"Pejdžer"</item>
    <item msgid="1692790665884224905">"Ostalo"</item>
    <item msgid="6216981255272016212">"Prilagođeno"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="7786349763648997741">"Kućni"</item>
    <item msgid="435564470865989199">"Posao"</item>
    <item msgid="4199433197875490373">"Ostalo"</item>
    <item msgid="3233938986670468328">"Prilagođeno"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="3861463339764243038">"Kuća"</item>
    <item msgid="5472578890164979109">"Posao"</item>
    <item msgid="5718921296646594739">"Ostalo"</item>
    <item msgid="5523122236731783179">"Prilagođeno"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="588088543406993772">"Kućni"</item>
    <item msgid="5503060422020476757">"Posao"</item>
    <item msgid="2530391194653760297">"Ostalo"</item>
    <item msgid="7640927178025203330">"Prilagođeno"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="6144047813304847762">"Posao"</item>
    <item msgid="7402720230065674193">"Ostalo"</item>
    <item msgid="808230403067569648">"Prilagođeno"</item>
  </string-array>
  <string-array name="imProtocols">
    <item msgid="7535761744432206400">"AIM"</item>
    <item msgid="2236558491789293993">"Windows Live"</item>
    <item msgid="4925858989398000295">"Yahoo"</item>
    <item msgid="5203383604393320577">"Skype"</item>
    <item msgid="6142060795155127001">"QQ"</item>
    <item msgid="8831467252725610081">"Google Talk"</item>
    <item msgid="4717545739447438044">"ICQ"</item>
    <item msgid="8293711853624033835">"Jabber"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="5120365721260686814">"Prilagođeno"</string>
    <string name="phoneTypeHome" msgid="3880132427643623588">"Kuća"</string>
    <string name="phoneTypeMobile" msgid="1178852541462086735">"Mobilni"</string>
    <string name="phoneTypeWork" msgid="6604967163358864607">"Posao"</string>
    <string name="phoneTypeFaxWork" msgid="6757519896109439123">"Poslovni faks"</string>
    <string name="phoneTypeFaxHome" msgid="6678559953115904345">"Kućni faks"</string>
    <string name="phoneTypePager" msgid="576402072263522767">"Pejdžer"</string>
    <string name="phoneTypeOther" msgid="6918196243648754715">"Ostalo"</string>
    <string name="phoneTypeCallback" msgid="3455781500844157767">"Povratni poziv"</string>
    <string name="phoneTypeCar" msgid="4604775148963129195">"Automobil"</string>
    <string name="phoneTypeCompanyMain" msgid="4482773154536455441">"Poslovni glavni"</string>
    <string name="phoneTypeIsdn" msgid="2496238954533998512">"ISDN"</string>
    <string name="phoneTypeMain" msgid="5199722006991000111">"Glavni"</string>
    <string name="phoneTypeOtherFax" msgid="3037145630364770357">"Drugi faks"</string>
    <string name="phoneTypeRadio" msgid="2637819130239264771">"Radio"</string>
    <string name="phoneTypeTelex" msgid="2558783611711876562">"Teleks"</string>
    <string name="phoneTypeTtyTdd" msgid="532038552105328779">"TTY TDD"</string>
    <string name="phoneTypeWorkMobile" msgid="7522314392003565121">"Poslovni mobilni"</string>
    <string name="phoneTypeWorkPager" msgid="3748332310638505234">"Poslovni pejdžer"</string>
    <string name="phoneTypeAssistant" msgid="757550783842231039">"Asistent"</string>
    <string name="phoneTypeMms" msgid="1799747455131365989">"MMS"</string>
    <string name="eventTypeCustom" msgid="3257367158986466481">"Prilagođeno"</string>
    <string name="eventTypeBirthday" msgid="7770026752793912283">"Rođendan"</string>
    <string name="eventTypeAnniversary" msgid="4684702412407916888">"Godišnjica"</string>
    <string name="eventTypeOther" msgid="530671238533887997">"Ostalo"</string>
    <string name="emailTypeCustom" msgid="1809435350482181786">"Prilagođeno"</string>
    <string name="emailTypeHome" msgid="1597116303154775999">"Privatna"</string>
    <string name="emailTypeWork" msgid="2020095414401882111">"Posao"</string>
    <string name="emailTypeOther" msgid="5131130857030897465">"Drugo"</string>
    <string name="emailTypeMobile" msgid="787155077375364230">"Mobilni"</string>
    <string name="postalTypeCustom" msgid="5645590470242939129">"Prilagođeno"</string>
    <string name="postalTypeHome" msgid="7562272480949727912">"Kućna adresa"</string>
    <string name="postalTypeWork" msgid="8553425424652012826">"Posao"</string>
    <string name="postalTypeOther" msgid="7094245413678857420">"Ostalo"</string>
    <string name="imTypeCustom" msgid="5653384545085765570">"Prilagođeno"</string>
    <string name="imTypeHome" msgid="6996507981044278216">"Kuća"</string>
    <string name="imTypeWork" msgid="2099668940169903123">"Posao"</string>
    <string name="imTypeOther" msgid="8068447383276219810">"Ostalo"</string>
    <string name="imProtocolCustom" msgid="4437878287653764692">"Prilagođeno"</string>
    <string name="imProtocolAim" msgid="4050198236506604378">"AIM"</string>
    <string name="imProtocolMsn" msgid="2257148557766499232">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="5373338758093392231">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="1486297589164830043">"Skype"</string>
    <string name="imProtocolQq" msgid="7254708777029006592">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="9194016024343166782">"Hangouts"</string>
    <string name="imProtocolIcq" msgid="2410325380427389521">"ICQ"</string>
    <string name="imProtocolJabber" msgid="7919269388889582015">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="4985002408136148256">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="8684458700669564172">"Posao"</string>
    <string name="orgTypeOther" msgid="5450675258408005553">"Ostalo"</string>
    <string name="orgTypeCustom" msgid="1126322047677329218">"Prilagođeno"</string>
    <string name="relationTypeCustom" msgid="282938315217441351">"Prilagođeno"</string>
    <string name="relationTypeAssistant" msgid="4057605157116589315">"Asistent"</string>
    <string name="relationTypeBrother" msgid="7141662427379247820">"Brat"</string>
    <string name="relationTypeChild" msgid="9076258911292693601">"Dijete"</string>
    <string name="relationTypeDomesticPartner" msgid="7825306887697559238">"Nevjenčani partner"</string>
    <string name="relationTypeFather" msgid="3856225062864790596">"Otac"</string>
    <string name="relationTypeFriend" msgid="3192092625893980574">"Prijatelj"</string>
    <string name="relationTypeManager" msgid="2272860813153171857">"Šef"</string>
    <string name="relationTypeMother" msgid="2331762740982699460">"Majka"</string>
    <string name="relationTypeParent" msgid="4177920938333039882">"Roditelj"</string>
    <string name="relationTypePartner" msgid="4018017075116766194">"Partner"</string>
    <string name="relationTypeReferredBy" msgid="5285082289602849400">"Uputio(la)"</string>
    <string name="relationTypeRelative" msgid="3396498519818009134">"Rođak/ica"</string>
    <string name="relationTypeSister" msgid="3721676005094140671">"Sestra"</string>
    <string name="relationTypeSpouse" msgid="6916682664436031703">"Suprug/a"</string>
    <string name="sipAddressTypeCustom" msgid="6283889809842649336">"Prilagođeno"</string>
    <string name="sipAddressTypeHome" msgid="5918441930656878367">"Kuća"</string>
    <string name="sipAddressTypeWork" msgid="7873967986701216770">"Posao"</string>
    <string name="sipAddressTypeOther" msgid="6317012577345187275">"Ostalo"</string>
    <string name="quick_contacts_not_available" msgid="1262709196045052223">"Nije pronađena aplikacija za pregled ovog kontakta."</string>
    <string name="keyguard_password_enter_pin_code" msgid="6401406801060956153">"Unesite PIN"</string>
    <string name="keyguard_password_enter_puk_code" msgid="3112256684547584093">"Unesite PUK i novi PIN"</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="2825313071899938305">"PUK kôd"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="5505434724229581207">"Novi PIN"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="4032288032993261520"><font size="17">"Dodirnite za unos lozinke"</font></string>
    <string name="keyguard_password_enter_password_code" msgid="2751130557661643482">"Unesite lozinku za otključavanje tipkovnice"</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="7792964196473964340">"Unesite PIN za otključavanje tipkovnice"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="8583732939138432793">"Pogrešan PIN."</string>
    <string name="keyguard_label_text" msgid="3841953694564168384">"Za otključavanje telefona pritisnite dugme Meni, pa dugme 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="2978165477085612673">"Broj za hitne slučajeve"</string>
    <string name="lockscreen_carrier_default" msgid="6192313772955399160">"Nema mreže"</string>
    <string name="lockscreen_screen_locked" msgid="7364905540516041817">"Ekran zaključan."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="7982445492532123308">"Pritisnite dugme Meni kako biste otključali uređaj ili obavili hitni poziv."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="7434061749374801753">"Pritisnite dugme Meni za otključavanje uređaja."</string>
    <string name="lockscreen_pattern_instructions" msgid="3169991838169244941">"Nacrtajte uzorak za otključavanje"</string>
    <string name="lockscreen_emergency_call" msgid="7500692654885445299">"Hitno"</string>
    <string name="lockscreen_return_to_call" msgid="3156883574692006382">"Povratak na poziv"</string>
    <string name="lockscreen_pattern_correct" msgid="8050630103651508582">"Ispravno!"</string>
    <string name="lockscreen_pattern_wrong" msgid="2940138714468358458">"Pokušajte ponovo"</string>
    <string name="lockscreen_password_wrong" msgid="8605355913868947490">"Pokušajte ponovo"</string>
    <string name="lockscreen_storage_locked" msgid="634993789186443380">"Otključajte uređaj za sve funkcije i podatke"</string>
    <string name="faceunlock_multiple_failures" msgid="681991538434031708">"Premašen maksimalni broj pokušaja otključavanja licem"</string>
    <string name="lockscreen_missing_sim_message_short" msgid="1248431165144893792">"Nema SIM kartice"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="8596805728510570760">"Nema SIM kartice u tabletu."</string>
    <string name="lockscreen_missing_sim_message" product="tv" msgid="2582768023352171073">"U vašem Android TV uređaju nema SIM kartice."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="1408695081255172556">"Nema SIM kartice u telefonu."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="8473601862688263903">"Umetnite SIM karticu."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3664999892038416334">"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="3812893366715730539">"Neupotrebljiva SIM kartica."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="4358929052509450807">"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="2879469521751181478">"Prethodna numera"</string>
    <string name="lockscreen_transport_next_description" msgid="2931509904881099919">"Sljedeća numera"</string>
    <string name="lockscreen_transport_pause_description" msgid="6705284702135372494">"Pauziraj"</string>
    <string name="lockscreen_transport_play_description" msgid="106868788691652733">"Reproduciraj"</string>
    <string name="lockscreen_transport_stop_description" msgid="1449552232598355348">"Zaustavi"</string>
    <string name="lockscreen_transport_rew_description" msgid="7680106856221622779">"Premotaj"</string>
    <string name="lockscreen_transport_ffw_description" msgid="4763794746640196772">"Ubrzaj"</string>
    <string name="emergency_calls_only" msgid="3057351206678279851">"Samo hitni pozivi"</string>
    <string name="lockscreen_network_locked_message" msgid="2814046965899249635">"Mreža zaključana"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="6618356415831082174">"SIM kartica je zaključana PUK-om."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="5307979043730860995">"Pogledajte Priručnik za korištenje ili kontaktirajte odjel za brigu o kupcima."</string>
    <string name="lockscreen_sim_locked_message" msgid="3160196135801185938">"SIM kartica je zaključana."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="2286497117428409709">"Otključavanje SIM kartice..."</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6458790975898594240">"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="3118353451602377380">"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="2874278239714821984">"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="3069635524964070596">"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="6399092175942158529">"Pogrešno ste unijeli uzorak za otključavanje <xliff:g id="NUMBER_0">%1$d</xliff:g> put(a). U slučaju još <xliff:g id="NUMBER_1">%2$d</xliff:g> pokušaja bez uspjeha, morat ćete otključati Android TV uređaj prijavom na svoj Google račun.\n\n Pokušajte ponovo za <xliff:g id="NUMBER_2">%3$d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="5691623136957148335">"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="7914445759242151426">"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="4275591249631864248">"Pokušali ste neispravno otključati Android TV uređaj <xliff:g id="NUMBER_0">%1$d</xliff:g> put(a). U slučaju još <xliff:g id="NUMBER_1">%2$d</xliff:g> pokušaja bez uspjeha, vaš Android TV će se vratiti na fabričke postavke i svi korisnički podaci će biti izgubljeni."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="1166532464798446579">"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="8682445539263683414">"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="2205435033340091883">"Pokušali ste neispravno otključati Android TV uređaj <xliff:g id="NUMBER">%d</xliff:g> put(a). Vaš Android TV uređaj će se sada vratiti na fabričke postavke."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="2203704707679895487">"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="6807200118164539589">"Broj sekundi do sljedećeg pokušaja: <xliff:g id="NUMBER">%d</xliff:g>"</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="8362442730606839031">"Zaboravili ste uzorak?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="9218940117797602518">"Otključavanje pomoću Google računa"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="3775904917743034195">"Previše puta ste pokušali otključati uređaj unosom uzorka"</string>
    <string name="lockscreen_glogin_instructions" msgid="4695162942525531700">"Kako biste otključali telefon, prijavite se na svoj Google račun."</string>
    <string name="lockscreen_glogin_username_hint" msgid="6916101478673157045">"Korisničko ime (e-mail)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="3031027901286812848">"Lozinka"</string>
    <string name="lockscreen_glogin_submit_button" msgid="3590556636347843733">"Prijava"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="4369219936865697679">"Pogrešno korisničko ime ili lozinka."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1683405808525090649">"Zaboravili ste korisničko ime ili lozinku?\nPosjetite "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="lockscreen_glogin_checking_password" msgid="2607271802803381645">"Provjera u toku..."</string>
    <string name="lockscreen_unlock_label" msgid="4648257878373307582">"Otključaj"</string>
    <string name="lockscreen_sound_on_label" msgid="1660281470535492430">"Zvuk uključen"</string>
    <string name="lockscreen_sound_off_label" msgid="2331496559245450053">"Isključi zvuk"</string>
    <string name="lockscreen_access_pattern_start" msgid="3778502525702613399">"Uzorak započet"</string>
    <string name="lockscreen_access_pattern_cleared" msgid="7493849102641167049">"Uzorak izbrisan"</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6746676335293144163">"Ćelija dodana"</string>
    <string name="lockscreen_access_pattern_cell_added_verbose" msgid="2931364927622563465">"Ćelija <xliff:g id="CELL_INDEX">%1$s</xliff:g> je dodana"</string>
    <string name="lockscreen_access_pattern_detected" msgid="3931150554035194012">"Uzorak unesen"</string>
    <string name="lockscreen_access_pattern_area" msgid="1288780416685002841">"Oblast za unošenje obrasca."</string>
    <string name="keyguard_accessibility_widget_changed" msgid="7298011259508200234">"%1$s. Widget %2$d od %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8245795023551343672">"Dodaj widget."</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="544239307077644480">"Prazno"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="7768634718706488951">"Oblast za otključavanje je proširena."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="4729922043778400434">"Oblast za otključavanje je smanjena."</string>
    <string name="keyguard_accessibility_widget" msgid="6776892679715699875">"Widget za <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>."</string>
    <string name="keyguard_accessibility_user_selector" msgid="1466067610235696600">"Biranje korisnika"</string>
    <string name="keyguard_accessibility_status" msgid="6792745049712397237">"Status"</string>
    <string name="keyguard_accessibility_camera" msgid="7862557559464986528">"Kamera"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="2267379779900620614">"Upravljanje medijima"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="7066213328912939191">"Promjena rasporeda widgeta je počela."</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="1083806817600593490">"Promjena rasporeda widgeta je završena."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="1509738950119878705">"Widget <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> je izbrisan."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="4215280881346033434">"Proširi oblast za otključavanje."</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2968195219692413046">"Otključavanje pomoću klizača."</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="8669128146589233293">"Otključavanje uzorkom."</string>
    <string name="keyguard_accessibility_face_unlock" msgid="4533832120787386728">"Otključavanje licem."</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="4020864007967340068">"Otključavanje pinom."</string>
    <string name="keyguard_accessibility_sim_pin_unlock" msgid="4895939120871890557">"Otključavanje Pin-om za Sim."</string>
    <string name="keyguard_accessibility_sim_puk_unlock" msgid="3459003464041899101">"Otključavanje SIM-a PUK-om"</string>
    <string name="keyguard_accessibility_password_unlock" msgid="6130186108581153265">"Otključavanje lozinkom."</string>
    <string name="keyguard_accessibility_pattern_area" msgid="1419570880512350689">"Uzorak oblasti."</string>
    <string name="keyguard_accessibility_slide_area" msgid="4331399051142520176">"Oblast za pomjeranje klizača."</string>
    <string name="password_keyboard_label_symbol_key" msgid="2716255580853511949">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="5294837425652726684">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="8528261816395508841">"ALT"</string>
    <string name="granularity_label_character" msgid="8903387663153706317">"znak"</string>
    <string name="granularity_label_word" msgid="3686589158760620518">"riječ"</string>
    <string name="granularity_label_link" msgid="9007852307112046526">"link"</string>
    <string name="granularity_label_line" msgid="376204904280620221">"linija"</string>
    <string name="factorytest_failed" msgid="3190979160945298006">"Fabrički test nije uspio"</string>
    <string name="factorytest_not_system" msgid="5658160199925519869">"Akcija FACTORY_TEST podržana je samo za pakete instalirane u facsikli /system/app."</string>
    <string name="factorytest_no_action" msgid="339252838115675515">"Nije pronađen paket koji omogućava akciju FACTORY_TEST."</string>
    <string name="factorytest_reboot" msgid="2050147445567257365">"Ponovno pokretanje"</string>
    <string name="js_dialog_title" msgid="7464775045615023241">"Stranica na \"<xliff:g id="TITLE">%s</xliff:g>\" kaže:"</string>
    <string name="js_dialog_title_default" msgid="3769524569903332476">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="7012587995876771246">"Potvrdite navigaciju"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="4274257182303565509">"Napusti ovu stranicu"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="3873765747622415310">"Ostani na ovoj stranici"</string>
    <string name="js_dialog_before_unload" msgid="7213364985774778744">"<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="9161712335355510035">"Potvrdite"</string>
    <string name="double_tap_toast" msgid="7065519579174882778">"Savjet: Dodirnite ekran dva puta za uvećanje ili smanjenje prikaza."</string>
    <string name="autofill_this_form" msgid="3187132440451621492">"Autofill"</string>
    <string name="setup_autofill" msgid="5431369130866618567">"Podesite Autofill"</string>
    <string name="autofill_window_title" msgid="4379134104008111961">"Automatsko popunjavanje koje pruža usluga <xliff:g id="SERVICENAME">%1$s</xliff:g>"</string>
    <string name="autofill_address_name_separator" msgid="8190155636149596125">" "</string>
    <string name="autofill_address_summary_name_format" msgid="3402882515222673691">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="760522655085707045">", "</string>
    <string name="autofill_address_summary_format" msgid="8417010069362125194">"$1$2$3"</string>
    <string name="autofill_province" msgid="3676846437741893159">"Pokrajina"</string>
    <string name="autofill_postal_code" msgid="7034789388968295591">"Poštanski broj"</string>
    <string name="autofill_state" msgid="3341725337190434069">"Država"</string>
    <string name="autofill_zip_code" msgid="1315503730274962450">"Poštanski broj"</string>
    <string name="autofill_county" msgid="7781382735643492173">"Okrug"</string>
    <string name="autofill_island" msgid="5367139008536593734">"Ostrvo"</string>
    <string name="autofill_district" msgid="6428712062213557327">"Distrikt"</string>
    <string name="autofill_department" msgid="9047276226873531529">"Odsjek"</string>
    <string name="autofill_prefecture" msgid="7267397763720241872">"Prefektura"</string>
    <string name="autofill_parish" msgid="6847960518334530198">"Parohija"</string>
    <string name="autofill_area" msgid="8289022370678448983">"Oblast"</string>
    <string name="autofill_emirate" msgid="2544082046790551168">"Emirat"</string>
    <string name="permlab_readHistoryBookmarks" msgid="9102293913842539697">"čitanje internet oznaka i historije"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="2323799501008967852">"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="6090259925187986937">"pisanje internet oznaka i historije"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="573341025292489065">"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="88642768580408561">"Omogućava aplikaciji da mijenja historiju ili oznake preglednika pohranjene na Android TV uređaju. Na ovaj način se aplikaciji može omogućiti brisanje ili izmjena podataka preglednika. Napomena: Ovu dozvolu ne mogu iskoristiti preglednici trećih strana ili druge aplikacije koje imaju mogućnost pregleda interneta."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="2245203087160913652">"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="1158001610254173567">"postavljanje alarma"</string>
    <string name="permdesc_setAlarm" msgid="2185033720060109640">"Dozvoljava aplikaciji postavljanje alarma u instaliranom budilniku. Moguće je da neki budilnici neće primijeniti ovu funkciju."</string>
    <string name="permlab_addVoicemail" msgid="4770245808840814471">"dodavanje govorne pošte"</string>
    <string name="permdesc_addVoicemail" msgid="5470312139820074324">"Dozvoljava aplikaciji dodavanje poruka u vašu ulaznu govornu poštu."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="8605631647492879449">"izmjena geolokacijskih odobrenja preglednika"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="5817346421222227772">"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="2146409467245462965">"Želite li da preglednik zapamti ovu lozinku?"</string>
    <string name="save_password_notnow" msgid="2878327088951240061">"Ne sada"</string>
    <string name="save_password_remember" msgid="6490888932657708341">"Zapamti"</string>
    <string name="save_password_never" msgid="6776808375903410659">"Nikad"</string>
    <string name="open_permission_deny" msgid="5136793905306987251">"Nemate odobrenje za otvaranje ove stranice."</string>
    <string name="text_copied" msgid="2531420577879738860">"Tekst kopiran u međumemoriju."</string>
    <string name="pasted_from_app" msgid="5627698450808256545">"Aplikacija <xliff:g id="PASTING_APP_NAME">%1$s</xliff:g> je zalijepljena iz aplikacije <xliff:g id="SOURCE_APP_NAME">%2$s</xliff:g>"</string>
    <string name="pasted_from_clipboard" msgid="7355790625710831847">"Aplikacija <xliff:g id="PASTING_APP_NAME">%1$s</xliff:g> je zalijepila sadržaj iz međumemorije"</string>
    <string name="pasted_text" msgid="4298871641549173733">"Aplikacija <xliff:g id="PASTING_APP_NAME">%1$s</xliff:g> je zalijepila kopirani tekst"</string>
    <string name="pasted_image" msgid="4729097394781491022">"Aplikacija <xliff:g id="PASTING_APP_NAME">%1$s</xliff:g> je zalijepila kopiranu sliku"</string>
    <string name="pasted_content" msgid="646276353060777131">"Aplikacija <xliff:g id="PASTING_APP_NAME">%1$s</xliff:g> je zalijepila kopirani sadržaj"</string>
    <string name="more_item_label" msgid="7419249600215749115">"Više"</string>
    <string name="prepend_shortcut_label" msgid="1743716737502867951">"Meni+"</string>
    <string name="menu_meta_shortcut_label" msgid="1623390163674762478">"Meta+"</string>
    <string name="menu_ctrl_shortcut_label" msgid="131911133027196485">"Ctrl+"</string>
    <string name="menu_alt_shortcut_label" msgid="343761069945250991">"Alt+"</string>
    <string name="menu_shift_shortcut_label" msgid="5443936876111232346">"Shift+"</string>
    <string name="menu_sym_shortcut_label" msgid="4037566049061218776">"Sym+"</string>
    <string name="menu_function_shortcut_label" msgid="2367112760987662566">"Function+"</string>
    <string name="menu_space_shortcut_label" msgid="5949311515646872071">"razmak"</string>
    <string name="menu_enter_shortcut_label" msgid="6709499510082897320">"potvrdi"</string>
    <string name="menu_delete_shortcut_label" msgid="4365787714477739080">"izbriši"</string>
    <string name="search_go" msgid="2141477624421347086">"Pretraži"</string>
    <string name="search_hint" msgid="455364685740251925">"Pretražite..."</string>
    <string name="searchview_description_search" msgid="1045552007537359343">"Pretraživanje"</string>
    <string name="searchview_description_query" msgid="7430242366971716338">"Upit za pretragu"</string>
    <string name="searchview_description_clear" msgid="1989371719192982900">"Obriši upit"</string>
    <string name="searchview_description_submit" msgid="6771060386117334686">"Potvrditi upit"</string>
    <string name="searchview_description_voice" msgid="42360159504884679">"Glasovno pretraživanje"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="5095399706284943314">"Želite li omogućiti Istraživanje dodirom?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="1037295476738940824">"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="4312979647356179250">"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="4538030857114635777">"Prije mjesec dana"</string>
    <string name="beforeOneMonthDurationPast" msgid="8315149541372065392">"Prije više od mjesec dana"</string>
    <string name="last_num_days" msgid="2393660431490280537">"{count,plural, =1{Posljednji # dan}one{Posljednji # dan}few{Posljednja # dana}other{Posljednjih # dana}}"</string>
    <string name="last_month" msgid="1528906781083518683">"Prošli mjesec"</string>
    <string name="older" msgid="1645159827884647400">"Starije"</string>
    <string name="preposition_for_date" msgid="2780767868832729599">"<xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="4336835286453822053">"u <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="3149809685340130039">"godine <xliff:g id="YEAR">%s</xliff:g>"</string>
    <string name="day" msgid="8394717255950176156">"dan"</string>
    <string name="days" msgid="4570879797423034973">"dana"</string>
    <string name="hour" msgid="7796325297097314653">"sat"</string>
    <string name="hours" msgid="8517014849629200683">"sati"</string>
    <string name="minute" msgid="8369209540986467610">"minuta"</string>
    <string name="minutes" msgid="3456532942641808971">"minute"</string>
    <string name="second" msgid="9210875257112211713">"sekunda"</string>
    <string name="seconds" msgid="2175052687727971048">"s"</string>
    <string name="week" msgid="907127093960923779">"sedmica"</string>
    <string name="weeks" msgid="3516247214269821391">"sedmice"</string>
    <string name="year" msgid="5182610307741238982">"godina"</string>
    <string name="years" msgid="5797714729103773425">"godine"</string>
    <string name="now_string_shortest" msgid="3684914126941650330">"sada"</string>
    <string name="duration_minutes_shortest" msgid="5744379079540806690">"<xliff:g id="COUNT">%d</xliff:g> m"</string>
    <string name="duration_hours_shortest" msgid="1477752094141971675">"<xliff:g id="COUNT">%d</xliff:g> h"</string>
    <string name="duration_days_shortest" msgid="4083124701676227233">"<xliff:g id="COUNT">%d</xliff:g> d"</string>
    <string name="duration_years_shortest" msgid="483982719231145618">"<xliff:g id="COUNT">%d</xliff:g> g"</string>
    <string name="duration_minutes_shortest_future" msgid="5260857299282734759">"za <xliff:g id="COUNT">%d</xliff:g> m"</string>
    <string name="duration_hours_shortest_future" msgid="2979276794547981674">"za <xliff:g id="COUNT">%d</xliff:g> h"</string>
    <string name="duration_days_shortest_future" msgid="3392722163935571543">"za <xliff:g id="COUNT">%d</xliff:g> d"</string>
    <string name="duration_years_shortest_future" msgid="5537464088352970388">"za <xliff:g id="COUNT">%d</xliff:g> g"</string>
    <string name="duration_minutes_relative" msgid="8620337701051015593">"{count,plural, =1{Prije # min}one{Prije # min}few{Prije # min}other{Prije # min}}"</string>
    <string name="duration_hours_relative" msgid="4836449961693180253">"{count,plural, =1{Prije # h}one{Prije # h}few{Prije # h}other{Prije # h}}"</string>
    <string name="duration_days_relative" msgid="621965767567258302">"{count,plural, =1{Prije # dan}one{Prije # dan}few{Prije # dana}other{Prije # dana}}"</string>
    <string name="duration_years_relative" msgid="8731202348869424370">"{count,plural, =1{Prije # godinu}one{Prije # godinu}few{Prije # godine}other{Prije # godina}}"</string>
    <string name="duration_minutes_relative_future" msgid="5259574171747708115">"{count,plural, =1{# min}one{# min}few{# min}other{# min}}"</string>
    <string name="duration_hours_relative_future" msgid="6670440478481140565">"{count,plural, =1{# h}one{# h}few{# h}other{# h}}"</string>
    <string name="duration_days_relative_future" msgid="8870658635774250746">"{count,plural, =1{# dan}one{# dan}few{# dana}other{# dana}}"</string>
    <string name="duration_years_relative_future" msgid="8855853883925918380">"{count,plural, =1{# godina}one{# godina}few{# godine}other{# godina}}"</string>
    <string name="VideoView_error_title" msgid="5750686717225068016">"Problem sa prikazom video sadržaja"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3782449246085134720">"Prijenos ovog video sadržaja ne može se izvršiti na ovom uređaju."</string>
    <string name="VideoView_error_text_unknown" msgid="7658683339707607138">"Greška prilikom reproduciranja video sadržaja."</string>
    <string name="VideoView_error_button" msgid="5138809446603764272">"Uredu"</string>
    <string name="relative_time" msgid="8572030016028033243">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="8365974533050605886">"podne"</string>
    <string name="Noon" msgid="6902418443846838189">"Podne"</string>
    <string name="midnight" msgid="3646671134282785114">"ponoć"</string>
    <string name="Midnight" msgid="8176019203622191377">"Ponoć"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="8689459651807876423">"<xliff:g id="MINUTES">%1$02d</xliff:g>:<xliff:g id="SECONDS">%2$02d</xliff:g>"</string>
    <string name="elapsed_time_short_format_h_mm_ss" msgid="2302144714803345056">"<xliff:g id="HOURS">%1$d</xliff:g>:<xliff:g id="MINUTES">%2$02d</xliff:g>:<xliff:g id="SECONDS">%3$02d</xliff:g>"</string>
    <string name="selectAll" msgid="1532369154488982046">"Odaberi sve"</string>
    <string name="cut" msgid="2561199725874745819">"Izreži"</string>
    <string name="copy" msgid="5472512047143665218">"Kopiraj"</string>
    <string name="failed_to_copy_to_clipboard" msgid="725919885138539875">"Kopiranje u spremnik nije uspjelo"</string>
    <string name="paste" msgid="461843306215520225">"Zalijepi"</string>
    <string name="paste_as_plain_text" msgid="7664800665823182587">"Zalijepi kao neformatiran tekst"</string>
    <string name="replace" msgid="7842675434546657444">"Zamijeniti..."</string>
    <string name="delete" msgid="1514113991712129054">"Izbrišite"</string>
    <string name="copyUrl" msgid="6229645005987260230">"Kopirajte URL"</string>
    <string name="selectTextMode" msgid="3225108910999318778">"Odaberi tekst"</string>
    <string name="undo" msgid="3175318090002654673">"Vrati"</string>
    <string name="redo" msgid="7231448494008532233">"Ponovo uradi"</string>
    <string name="autofill" msgid="511224882647795296">"Automatsko popunjavanje"</string>
    <string name="textSelectionCABTitle" msgid="5151441579532476940">"Odabir teksta"</string>
    <string name="addToDictionary" msgid="8041821113480950096">"Dodajte u rječnik"</string>
    <string name="deleteText" msgid="4200807474529938112">"Izbriši"</string>
    <string name="inputMethod" msgid="1784759500516314751">"Način unosa"</string>
    <string name="editTextMenuTitle" msgid="857666911134482176">"Akcije za tekst"</string>
    <string name="input_method_nav_back_button_desc" msgid="3655838793765691787">"Nazad"</string>
    <string name="input_method_ime_switch_button_desc" msgid="2736542240252198501">"Promjena načina unosa"</string>
    <string name="low_internal_storage_view_title" msgid="9024241779284783414">"Ponestaje prostora za pohranu"</string>
    <string name="low_internal_storage_view_text" msgid="8172166728369697835">"Neke funkcije sistema možda neće raditi"</string>
    <string name="low_internal_storage_view_text_no_boot" msgid="7368968163411251788">"Nema dovoljno prostora za sistem. Obezbijedite 250MB slobodnog prostora i ponovo pokrenite uređaj."</string>
    <string name="app_running_notification_title" msgid="8985999749231486569">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> je pokrenuta"</string>
    <string name="app_running_notification_text" msgid="5120815883400228566">"Dodirnite za više informacija ili da biste zaustavili aplikaciju."</string>
    <string name="ok" msgid="2646370155170753815">"Uredu"</string>
    <string name="cancel" msgid="6908697720451760115">"Otkaži"</string>
    <string name="yes" msgid="9069828999585032361">"Uredu"</string>
    <string name="no" msgid="5122037903299899715">"Otkaži"</string>
    <string name="dialog_alert_title" msgid="651856561974090712">"Pažnja"</string>
    <string name="loading" msgid="3138021523725055037">"Učitavanje..."</string>
    <string name="capital_on" msgid="2770685323900821829">"Uključeno"</string>
    <string name="capital_off" msgid="7443704171014626777">"Isključeno"</string>
    <string name="checked" msgid="9179896827054513119">"označeno"</string>
    <string name="not_checked" msgid="7972320087569023342">"nije označeno"</string>
    <string name="selected" msgid="6614607926197755875">"odabrano"</string>
    <string name="not_selected" msgid="410652016565864475">"nije odabrano"</string>
    <string name="in_progress" msgid="2149208189184319441">"u toku"</string>
    <string name="whichApplication" msgid="5432266899591255759">"Završite radnju pomoću aplikacije"</string>
    <string name="whichApplicationNamed" msgid="6969946041713975681">"Završite radnju pomoću aplikacije %1$s"</string>
    <string name="whichApplicationLabel" msgid="7852182961472531728">"Izvršiti akciju"</string>
    <string name="whichViewApplication" msgid="5733194231473132945">"Otvori koristeći"</string>
    <string name="whichViewApplicationNamed" msgid="415164730629690105">"Otvori koristeći %1$s"</string>
    <string name="whichViewApplicationLabel" msgid="7367556735684742409">"Otvori"</string>
    <string name="whichOpenHostLinksWith" msgid="7645631470199397485">"Otvaranje <xliff:g id="HOST">%1$s</xliff:g> linkova pomoću preglednika/aplikacije"</string>
    <string name="whichOpenLinksWith" msgid="1120936181362907258">"Otvaranje linkova pomoću preglednika"</string>
    <string name="whichOpenLinksWithApp" msgid="6917864367861910086">"Otvaranje linkova pomoću preglednika <xliff:g id="APPLICATION">%1$s</xliff:g>"</string>
    <string name="whichOpenHostLinksWithApp" msgid="2401668560768463004">"Otvaranje <xliff:g id="HOST">%1$s</xliff:g> linkova pomoću preglednika <xliff:g id="APPLICATION">%2$s</xliff:g>"</string>
    <string name="whichGiveAccessToApplicationLabel" msgid="7805857277166106236">"Dozvoli pristup"</string>
    <string name="whichEditApplication" msgid="6191568491456092812">"Uredi koristeći"</string>
    <string name="whichEditApplicationNamed" msgid="8096494987978521514">"Uredi koristeći %1$s"</string>
    <string name="whichEditApplicationLabel" msgid="1463288652070140285">"Uredi"</string>
    <string name="whichSendApplication" msgid="4143847974460792029">"Dijeli"</string>
    <string name="whichSendApplicationNamed" msgid="4470386782693183461">"Dijeli koristeći %1$s"</string>
    <string name="whichSendApplicationLabel" msgid="7467813004769188515">"Dijeli"</string>
    <string name="whichSendToApplication" msgid="77101541959464018">"Pošalji koristeći"</string>
    <string name="whichSendToApplicationNamed" msgid="3385686512014670003">"Pošalji koristeći %1$s"</string>
    <string name="whichSendToApplicationLabel" msgid="3543240188816513303">"Pošalji"</string>
    <string name="whichHomeApplication" msgid="8276350727038396616">"Odaberi glavnu aplikaciju"</string>
    <string name="whichHomeApplicationNamed" msgid="5855990024847433794">"Koristi %1$s kao glavnu aplikaciju"</string>
    <string name="whichHomeApplicationLabel" msgid="8907334282202933959">"Snimanje slike"</string>
    <string name="whichImageCaptureApplication" msgid="2737413019463215284">"Snimanje slike koristeći"</string>
    <string name="whichImageCaptureApplicationNamed" msgid="8820702441847612202">"Snimanje slike koristeći %1$s"</string>
    <string name="whichImageCaptureApplicationLabel" msgid="6505433734824988277">"Snimanje slike"</string>
    <string name="alwaysUse" msgid="3153558199076112903">"Koristiti kao zadanu rezoluciju za ovu akciju."</string>
    <string name="use_a_different_app" msgid="4987790276170972776">"Koristi drugu aplikaciju"</string>
    <string name="clearDefaultHintMsg" msgid="1325866337702524936">"Obrišite zadane opcije u meniju Postavke sistema &gt; Aplikacije &gt; Preuzete aplikacije."</string>
    <string name="chooseActivity" msgid="8563390197659779956">"Odaberite akciju"</string>
    <string name="chooseUsbActivity" msgid="2096269989990986612">"Odaberite aplikaciju za USB uređaj"</string>
    <string name="noApplications" msgid="1186909265235544019">"Nijedna aplikacija ne može izvršiti ovu akciju."</string>
    <string name="aerr_application" msgid="4090916809370389109">"Aplikacija <xliff:g id="APPLICATION">%1$s</xliff:g> je zaustavljena"</string>
    <string name="aerr_process" msgid="4268018696970966407">"<xliff:g id="PROCESS">%1$s</xliff:g> je zaustavljen"</string>
    <string name="aerr_application_repeated" msgid="7804378743218496566">"<xliff:g id="APPLICATION">%1$s</xliff:g> se stalno zaustavlja"</string>
    <string name="aerr_process_repeated" msgid="1153152413537954974">"<xliff:g id="PROCESS">%1$s</xliff:g> se stalno zaustavlja"</string>
    <string name="aerr_restart" msgid="2789618625210505419">"Ponovo otvori aplikaciju"</string>
    <string name="aerr_report" msgid="3095644466849299308">"Pošalji povratne informacije"</string>
    <string name="aerr_close" msgid="3398336821267021852">"Zatvori"</string>
    <string name="aerr_mute" msgid="2304972923480211376">"Isključiti zvuk dok se uređaj ponovo ne pokrene"</string>
    <string name="aerr_wait" msgid="3198677780474548217">"Sačekaj"</string>
    <string name="aerr_close_app" msgid="8318883106083050970">"Zatvori aplikaciju"</string>
    <string name="anr_title" msgid="7290329487067300120"></string>
    <string name="anr_activity_application" msgid="8121716632960340680">"<xliff:g id="APPLICATION">%2$s</xliff:g> ne reaguje"</string>
    <string name="anr_activity_process" msgid="3477362583767128667">"<xliff:g id="ACTIVITY">%1$s</xliff:g> ne reaguje"</string>
    <string name="anr_application_process" msgid="4978772139461676184">"<xliff:g id="APPLICATION">%1$s</xliff:g> ne reaguje"</string>
    <string name="anr_process" msgid="1664277165911816067">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> ne reaguje"</string>
    <string name="force_close" msgid="9035203496368973803">"Uredu"</string>
    <string name="report" msgid="2149194372340349521">"Prijavi"</string>
    <string name="wait" msgid="7765985809494033348">"Sačekaj"</string>
    <string name="webpage_unresponsive" msgid="7850879412195273433">"Stranica ne reagira.\n\nŽelite li je zatvoriti?"</string>
    <string name="launch_warning_title" msgid="6725456009564953595">"Aplikacija preusmjerena"</string>
    <string name="launch_warning_replace" msgid="3073392976283203402">"Sada je pokrenuta aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="launch_warning_original" msgid="3332206576800169626">"Izvorno je pokrenuta aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="screen_compat_mode_scale" msgid="8627359598437527726">"Razmjer"</string>
    <string name="screen_compat_mode_show" msgid="5080361367584709857">"Uvijek prikaži"</string>
    <string name="screen_compat_mode_hint" msgid="4032272159093750908">"Ponovo omogućite ovu opciju u meniju Postavke sistema &gt; Aplikacije &gt; Preuzete aplikacije."</string>
    <string name="unsupported_display_size_message" msgid="7265211375269394699">"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="980129850974919375">"Uvijek prikaži"</string>
    <string name="unsupported_compile_sdk_message" msgid="7326293500707890537">"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="1601210057960312248">"Uvijek prikaži"</string>
    <string name="unsupported_compile_sdk_check_update" msgid="1103639989147664456">"Provjeri je li dostupno ažuriranje"</string>
    <string name="smv_application" msgid="3775183542777792638">"Aplikacija <xliff:g id="APPLICATION">%1$s</xliff:g> (proces <xliff:g id="PROCESS">%2$s</xliff:g>) prekršila je vlastita StrictMode pravila."</string>
    <string name="smv_process" msgid="1398801497130695446">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> prekršio je vlastita StrictMode pravila."</string>
    <string name="android_upgrading_title" product="default" msgid="7279077384220829683">"Ažuriranje telefona…"</string>
    <string name="android_upgrading_title" product="tablet" msgid="4268417249079938805">"Ažuriranje tableta…"</string>
    <string name="android_upgrading_title" product="device" msgid="6774767702998149762">"Ažuriranje uređaja…"</string>
    <string name="android_start_title" product="default" msgid="4036708252778757652">"Pokretanje telefona…"</string>
    <string name="android_start_title" product="automotive" msgid="7917984412828168079">"Android se pokreće..."</string>
    <string name="android_start_title" product="tablet" msgid="4429767260263190344">"Pokretanje tableta…"</string>
    <string name="android_start_title" product="device" msgid="6967413819673299309">"Pokretanje uređaja…"</string>
    <string name="android_upgrading_fstrim" msgid="3259087575528515329">"Optimiziranje pohrane."</string>
    <string name="android_upgrading_notification_title" product="default" msgid="3509927005342279257">"Dovršavanje ažuriranja sistema…"</string>
    <string name="app_upgrading_toast" msgid="1016267296049455585">"Aplikacija <xliff:g id="APPLICATION">%1$s</xliff:g> se nadograđuje…"</string>
    <string name="android_upgrading_apk" msgid="1339564803894466737">"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="589736917792300956">"Pripremanje aplikacije <xliff:g id="APPNAME">%1$s</xliff:g>."</string>
    <string name="android_upgrading_starting_apps" msgid="6206161195076057075">"Pokretanje aplikacija."</string>
    <string name="android_upgrading_complete" msgid="409800058018374746">"Pokretanje pri kraju."</string>
    <string name="fp_power_button_enrollment_message" msgid="5648173517663246140">"Pritisnuli ste dugme za uključivanje. Tako se obično isključuje ekran.\n\nPokušajte ga lagano dodirnuti dok postavljate otisak prsta."</string>
    <!-- no translation found for fp_power_button_enrollment_title (6976841690455338563) -->
    <skip />
    <!-- no translation found for fp_power_button_enrollment_button_text (3199783266386029200) -->
    <skip />
    <string name="fp_power_button_bp_title" msgid="5585506104526820067">"Nastaviti s potvrđivanjem otiska prsta?"</string>
    <string name="fp_power_button_bp_message" msgid="2983163038168903393">"Pritisnuli ste dugme za uključivanje. Tako se obično isključuje ekran.\n\nPokušajte ga lagano dodirnuti da potvrdite otisak prsta."</string>
    <string name="fp_power_button_bp_positive_button" msgid="728945472408552251">"Isključi ekran"</string>
    <string name="fp_power_button_bp_negative_button" msgid="3971364246496775178">"Nastavi"</string>
    <string name="heavy_weight_notification" msgid="8382784283600329576">"Pokrenuta je aplikacija <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="heavy_weight_notification_detail" msgid="6802247239468404078">"Dodirnite za povratak u igru"</string>
    <string name="heavy_weight_switcher_title" msgid="3861984210040100886">"Odaberite igru"</string>
    <string name="heavy_weight_switcher_text" msgid="6814316627367160126">"Radi boljih performansi, moguće je otvoriti samo po jednu od ovih igara."</string>
    <string name="old_app_action" msgid="725331621042848590">"Vrati se nazad u aplikaciju <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_action" msgid="547772182913269801">"Otvori aplikaciju <xliff:g id="NEW_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="1958903080400806644">"Aplikacija <xliff:g id="OLD_APP">%1$s</xliff:g> će se zatvoriti bez pohranjivanja"</string>
    <string name="dump_heap_notification" msgid="5316644945404825032">"<xliff:g id="PROC">%1$s</xliff:g> premašuje ograničenje memorije"</string>
    <string name="dump_heap_ready_notification" msgid="2302452262927390268">"Snimak dinamičkog dijela memorije procesa <xliff:g id="PROC">%1$s</xliff:g> je spreman"</string>
    <string name="dump_heap_notification_detail" msgid="8431586843001054050">"Snimak dinamičkog dijela memorije je napravljen. Dodirnite za dijeljenje."</string>
    <string name="dump_heap_title" msgid="4367128917229233901">"Želite li dijeliti snimak dinamičkog dijela memorije?"</string>
    <string name="dump_heap_text" msgid="1692649033835719336">"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="6805155514925350849">"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="5849618132123045516">"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="493003724401350724">"Biranje akcije za tekst"</string>
    <string name="volume_ringtone" msgid="134784084629229029">"Jačina zvuka zvona"</string>
    <string name="volume_music" msgid="7727274216734955095">"Jačina zvuka medija"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="2614142915948898228">"Medijski sadržaj se reproducira preko Bluetooth veze"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="1514829655029062233">"Postavljena nečujna melodija zvona"</string>
    <string name="volume_call" msgid="7625321655265747433">"Jačina zvuka poziva"</string>
    <string name="volume_bluetooth_call" msgid="2930204618610115061">"Jačina zvuka poziva putem Bluetootha"</string>
    <string name="volume_alarm" msgid="4486241060751798448">"Jačina zvuka alarma"</string>
    <string name="volume_notification" msgid="6864412249031660057">"Jačina zvuka za obavještenja"</string>
    <string name="volume_unknown" msgid="4041914008166576293">"Jačina zvuka"</string>
    <string name="volume_icon_description_bluetooth" msgid="7540388479345558400">"Jačina zvuka za Bluetooth vezu"</string>
    <string name="volume_icon_description_ringer" msgid="2187800636867423459">"Jačina zvuka melodije"</string>
    <string name="volume_icon_description_incall" msgid="4491255105381227919">"Jačina zvuka poziva"</string>
    <string name="volume_icon_description_media" msgid="4997633254078171233">"Jačina zvuka medija"</string>
    <string name="volume_icon_description_notification" msgid="579091344110747279">"Jačina zvuka za obavještenja"</string>
    <string name="ringtone_default" msgid="9118299121288174597">"Zadana melodija zvona"</string>
    <string name="ringtone_default_with_actual" msgid="2709686194556159773">"Zadano (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="397111123930141876">"Bez zvuka"</string>
    <string name="ringtone_picker_title" msgid="667342618626068253">"Melodije zvona"</string>
    <string name="ringtone_picker_title_alarm" msgid="7438934548339024767">"Zvukovi alarma"</string>
    <string name="ringtone_picker_title_notification" msgid="6387191794719608122">"Zvukovi obavještenja"</string>
    <string name="ringtone_unknown" msgid="5059495249862816475">"Nepoznato"</string>
    <string name="wifi_available_sign_in" msgid="381054692557675237">"Prijavljivanje na WiFi mrežu"</string>
    <string name="network_available_sign_in" msgid="1520342291829283114">"Prijava na mrežu"</string>
    <!-- no translation found for network_available_sign_in_detailed (7520423801613396556) -->
    <skip />
    <string name="wifi_no_internet" msgid="1386911698276448061">"Mreža <xliff:g id="NETWORK_SSID">%1$s</xliff:g> nema pristup internetu"</string>
    <string name="wifi_no_internet_detailed" msgid="634938444133558942">"Dodirnite za opcije"</string>
    <string name="mobile_no_internet" msgid="4014455157529909781">"Mobilna mreža nema pristup internetu"</string>
    <string name="other_networks_no_internet" msgid="6698711684200067033">"Mreža nema pristup internetu"</string>
    <string name="private_dns_broken_detailed" msgid="3709388271074611847">"Nije moguće pristupiti privatnom DNS serveru"</string>
    <string name="network_partial_connectivity" msgid="4791024923851432291">"Mreža <xliff:g id="NETWORK_SSID">%1$s</xliff:g> ima ograničenu povezivost"</string>
    <string name="network_partial_connectivity_detailed" msgid="5741329444564575840">"Dodirnite da se ipak povežete"</string>
    <string name="network_switch_metered" msgid="1531869544142283384">"Prebačeno na: <xliff:g id="NETWORK_TYPE">%1$s</xliff:g>"</string>
    <string name="network_switch_metered_detail" msgid="1358296010128405906">"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="501662047275723743">"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="2255670471736226365">"prijenos podataka na mobilnoj mreži"</item>
    <item msgid="5520925862115353992">"WiFi"</item>
    <item msgid="1055487873974272842">"Bluetooth"</item>
    <item msgid="1616528372438698248">"Ethernet"</item>
    <item msgid="9177085807664964627">"VPN"</item>
  </string-array>
    <string name="network_switch_type_name_unknown" msgid="3665696841646851068">"nepoznata vrsta mreže"</string>
    <string name="accept" msgid="5447154347815825107">"Prihvati"</string>
    <string name="decline" msgid="6490507610282145874">"Odbijte"</string>
    <string name="select_character" msgid="3352797107930786979">"Umetni znak"</string>
    <string name="sms_control_title" msgid="4748684259903148341">"Slanje SMS poruka"</string>
    <string name="sms_control_message" msgid="6574313876316388239">"&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="4858845109269524622">"Dozvoli"</string>
    <string name="sms_control_no" msgid="4845717880040355570">"Odbij"</string>
    <string name="sms_short_code_confirm_message" msgid="1385416688897538724">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; želi poslati 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="2723725738333388351">"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="1400296309866638111"><b>"Ovo će uzrokovati troškove na vašem računu za mobilne usluge."</b></string>
    <string name="sms_short_code_confirm_allow" msgid="920477594325526691">"Pošalji"</string>
    <string name="sms_short_code_confirm_deny" msgid="1356917469323768230">"Otkaži"</string>
    <string name="sms_short_code_remember_choice" msgid="1374526438647744862">"Zapamti moj izbor"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="2620984439143080410">"Ovo možete kasnije promijeniti u meniju Postavke &gt; Aplikacije"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="2223014893129755950">"Uvijek dozvoli"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="2688828813521652079">"Nikada ne dozvoli"</string>
    <string name="sim_removed_title" msgid="5387212933992546283">"SIM kartica uklonjena"</string>
    <string name="sim_removed_message" msgid="9051174064474904617">"Mobilna mreža neće biti dostupna dok ponovo ne pokrenete uređaj s umetnutom važećom SIM karticom."</string>
    <string name="sim_done_button" msgid="6464250841528410598">"Gotovo"</string>
    <string name="sim_added_title" msgid="7930779986759414595">"SIM kartica dodana"</string>
    <string name="sim_added_message" msgid="6602906609509958680">"Ponovo pokrenite uređaj da pristupite mobilnoj mreži."</string>
    <string name="sim_restart_button" msgid="8481803851341190038">"Ponovo pokreni"</string>
    <string name="install_carrier_app_notification_title" msgid="5712723402213090102">"Aktivirajte uslugu mobilne mreže"</string>
    <string name="install_carrier_app_notification_text" msgid="2781317581274192728">"Preuzmite aplikaciju operatera da aktivirate novi SIM"</string>
    <string name="install_carrier_app_notification_text_app_name" msgid="4086877327264106484">"Preuzmite aplikaciju <xliff:g id="APP_NAME">%1$s</xliff:g> da aktivirate novi SIM"</string>
    <string name="install_carrier_app_notification_button" msgid="6257740533102594290">"Preuzmite aplikaciju"</string>
    <string name="carrier_app_notification_title" msgid="5815477368072060250">"Nova SIM kartica je umetnuta"</string>
    <string name="carrier_app_notification_text" msgid="6567057546341958637">"Dodirnite da biste postavili"</string>
    <string name="time_picker_dialog_title" msgid="9053376764985220821">"Postavljanje vremena"</string>
    <string name="date_picker_dialog_title" msgid="5030520449243071926">"Postavljanje datuma"</string>
    <string name="date_time_set" msgid="4603445265164486816">"Postaviti"</string>
    <string name="date_time_done" msgid="8363155889402873463">"Gotovo"</string>
    <string name="perms_new_perm_prefix" msgid="6984556020395757087"><font size="12" fgcolor="#ff33b5e5">"NOVO: "</font></string>
    <string name="perms_description_app" msgid="2747752389870161996">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> omogućava."</string>
    <string name="no_permissions" msgid="5729199278862516390">"Nisu potrebna odobrenja"</string>
    <string name="perm_costs_money" msgid="749054595022779685">"ovo se možda dodatno plaća"</string>
    <string name="dlg_ok" msgid="5103447663504839312">"Uredu"</string>
    <string name="usb_charging_notification_title" msgid="1674124518282666955">"Punjenje uređaja putem USB-a"</string>
    <string name="usb_supplying_notification_title" msgid="5378546632408101811">"Punjenje povezanog uređaja putem USB-a"</string>
    <string name="usb_mtp_notification_title" msgid="1065989144124499810">"Uključen je način rada Prijenos fajlova putem USB-a"</string>
    <string name="usb_ptp_notification_title" msgid="5043437571863443281">"Uključen je način rada PTP putem USB-a"</string>
    <string name="usb_tether_notification_title" msgid="8828527870612663771">"Dijeljenje internetske veze putem USB-a je uključeno"</string>
    <string name="usb_midi_notification_title" msgid="7404506788950595557">"Uključen je način rada MIDI putem USB-a"</string>
    <string name="usb_accessory_notification_title" msgid="1385394660861956980">"Povezan je USB periferni uređaj"</string>
    <string name="usb_notification_message" msgid="4715163067192110676">"Dodirnite za više opcija."</string>
    <string name="usb_power_notification_message" msgid="7284765627437897702">"Punjenje povezanog uređaja. Dodirnite za više opcija."</string>
    <string name="usb_unsupported_audio_accessory_title" msgid="2335775548086533065">"Otkriven je analogni periferni uređaj"</string>
    <string name="usb_unsupported_audio_accessory_message" msgid="1300168007129796621">"Priključeni uređaj nije kompatibilan s ovim telefonom. Dodirnite da saznate više."</string>
    <string name="adb_active_notification_title" msgid="408390247354560331">"Otklanjanje grešaka putem USB-a je uspostavljeno"</string>
    <string name="adb_active_notification_message" msgid="5617264033476778211">"Dodirnite da isključite otklanjanje grešaka putem USB-a"</string>
    <string name="adb_active_notification_message" product="tv" msgid="6624498401272780855">"Odaberite da onemogućite otklanjanje grešaka putem USB-a"</string>
    <string name="adbwifi_active_notification_title" msgid="6147343659168302473">"Bežično otklanjanje grešaka je povezano"</string>
    <string name="adbwifi_active_notification_message" msgid="930987922852867972">"Dodirnite da isključite bežično otklanjanje grešaka"</string>
    <string name="adbwifi_active_notification_message" product="tv" msgid="8633421848366915478">"Odaberite da onemogućite bežično otklanjanje grešaka."</string>
    <string name="test_harness_mode_notification_title" msgid="2282785860014142511">"Omogućen način rada okvira za testiranje"</string>
    <string name="test_harness_mode_notification_message" msgid="3039123743127958420">"Izvršite vraćanje na fabričke postavke da onemogućite način rada okvira za testiranje."</string>
    <string name="console_running_notification_title" msgid="6087888939261635904">"Serijska konzola omogućena"</string>
    <string name="console_running_notification_message" msgid="7892751888125174039">"Performanse su smanjene. Da onemogućite, provjerite program za učitavanje operativnog sistema."</string>
    <string name="mte_override_notification_title" msgid="4731115381962792944">"Eksperimentalni MTE je omogućen"</string>
    <string name="mte_override_notification_message" msgid="2441170442725738942">"Moguće da će to uticati na performanse i stabilnost. Ponovo pokrenite da onemogućite. Ako je omogućeno pomoću arm64.memtag.bootctl, unaprijed ga postavite na \"Ništa\"."</string>
    <string name="usb_contaminant_detected_title" msgid="4359048603069159678">"Tečnost ili nečistoće u USB priključku"</string>
    <string name="usb_contaminant_detected_message" msgid="7346100585390795743">"USB priključak je automatski onemogućen. Dodirnite da saznate više."</string>
    <string name="usb_contaminant_not_detected_title" msgid="2651167729563264053">"USB priključak je sada sigurno koristiti"</string>
    <string name="usb_contaminant_not_detected_message" msgid="892863190942660462">"Telefon više ne detektira tečnost ili nečistoće."</string>
    <string name="taking_remote_bugreport_notification_title" msgid="1582531382166919850">"Prijem izvještaja o grešci..."</string>
    <string name="share_remote_bugreport_notification_title" msgid="6708897723753334999">"Podijeliti izvještaj o grešci?"</string>
    <string name="sharing_remote_bugreport_notification_title" msgid="3077385149217638550">"Dijeljenje izvještaja o grešci..."</string>
    <string name="share_remote_bugreport_notification_message_finished" msgid="7325635795739260135">"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="7630880678785123682">"PODIJELI"</string>
    <string name="decline_remote_bugreport_action" msgid="4040894777519784346">"ODBACI"</string>
    <string name="select_input_method" msgid="3971267998568587025">"Odaberite način unosa"</string>
    <string name="show_ime" msgid="6406112007347443383">"Prikaži na ekranu dok je fizička tastatura aktivna"</string>
    <string name="hardware" msgid="1800597768237606953">"Prikaz virtuelne tastature"</string>
    <string name="select_keyboard_layout_notification_title" msgid="4427643867639774118">"Konfigurirajte fizičku tastaturu"</string>
    <string name="select_keyboard_layout_notification_message" msgid="8835158247369158154">"Dodirnite za odabir jezika i rasporeda"</string>
    <string name="fast_scroll_alphabet" msgid="8854435958703888376">" ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="2529539945421557329">" 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="alert_windows_notification_channel_group_name" msgid="6063891141815714246">"Prikazivanje preko drugih aplikacija"</string>
    <string name="alert_windows_notification_channel_name" msgid="3437528564303192620">"Aplikacija <xliff:g id="NAME">%s</xliff:g> prekriva ostale aplikacije"</string>
    <string name="alert_windows_notification_title" msgid="6331662751095228536">"Aplikacija <xliff:g id="NAME">%s</xliff:g> prekriva druge apl."</string>
    <string name="alert_windows_notification_message" msgid="6538171456970725333">"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="7805857234839123780">"Isključi"</string>
    <string name="ext_media_checking_notification_title" msgid="8299199995416510094">"Provjeravanje medija <xliff:g id="NAME">%s</xliff:g>…"</string>
    <string name="ext_media_checking_notification_message" msgid="2231566971425375542">"Pregledanje trenutnog sadržaja"</string>
    <string name="ext_media_checking_notification_message" product="tv" msgid="7986154434946021415">"Analiziranje pohrane za medije"</string>
    <string name="ext_media_new_notification_title" msgid="3517407571407687677">"Novi medij <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_new_notification_title" product="automotive" msgid="9085349544984742727">"<xliff:g id="NAME">%s</xliff:g> ne funkcionira"</string>
    <string name="ext_media_new_notification_message" msgid="6095403121990786986">"Dodirnite za postavke"</string>
    <string name="ext_media_new_notification_message" product="tv" msgid="216863352100263668">"Odaberite da postavite"</string>
    <string name="ext_media_new_notification_message" product="automotive" msgid="5140127881613227162">"Možda ćete morati ponovo formatirati uređaj. Dodirnite da izbacite."</string>
    <string name="ext_media_ready_notification_message" msgid="7509496364380197369">"Za pohranjivanje fotografija, videozapisa, muzike i još mnogo toga"</string>
    <string name="ext_media_ready_notification_message" product="tv" msgid="8847134811163165935">"Pregledajte medijske fajlove"</string>
    <string name="ext_media_unmountable_notification_title" msgid="4895444667278979910">"Problem s medijem <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unmountable_notification_title" product="automotive" msgid="3142723758949023280">"<xliff:g id="NAME">%s</xliff:g> ne funkcionira"</string>
    <string name="ext_media_unmountable_notification_message" msgid="3256290114063126205">"Dodirnite da popravite"</string>
    <string name="ext_media_unmountable_notification_message" product="tv" msgid="3003611129979934633">"Uređaj <xliff:g id="NAME">%s</xliff:g> je oštećen. Odaberite za popravak."</string>
    <string name="ext_media_unmountable_notification_message" product="automotive" msgid="2274596120715020680">"Možda ćete morati ponovo formatirati uređaj. Dodirnite da izbacite."</string>
    <string name="ext_media_unsupported_notification_title" msgid="3487534182861251401">"Otkriven je medij <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unsupported_notification_title" product="automotive" msgid="6004193172658722381">"<xliff:g id="NAME">%s</xliff:g> ne funkcionira"</string>
    <string name="ext_media_unsupported_notification_message" msgid="8463636521459807981">"Dodirnite da postavite ."</string>
    <string name="ext_media_unsupported_notification_message" product="tv" msgid="1595482802187036532">"Odaberite da postavite medij (<xliff:g id="NAME">%s</xliff:g>) u podržanom formatu."</string>
    <string name="ext_media_unsupported_notification_message" product="automotive" msgid="3412494732736336330">"Možda ćete morati ponovo formatirati uređaj"</string>
    <string name="ext_media_badremoval_notification_title" msgid="4114625551266196872">"Neočekivano uklonjen uređaj <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_badremoval_notification_message" msgid="1986514704499809244">"Izbacite medij prije uklanjanja da izbjegnete gubitak sadržaja"</string>
    <string name="ext_media_nomedia_notification_title" msgid="742671636376975890">"Medij <xliff:g id="NAME">%s</xliff:g> je uklonjen"</string>
    <string name="ext_media_nomedia_notification_message" msgid="2832724384636625852">"Neke funkcionalnosti možda neće raditi ispravno. Ubacite novu pohranu."</string>
    <string name="ext_media_unmounting_notification_title" msgid="4147986383917892162">"Izbacivanje medija <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unmounting_notification_message" msgid="5717036261538754203">"Nemojte uklanjati"</string>
    <string name="ext_media_init_action" msgid="2312974060585056709">"Postavi"</string>
    <string name="ext_media_unmount_action" msgid="966992232088442745">"Izbaci"</string>
    <string name="ext_media_browse_action" msgid="344865351947079139">"Istraži"</string>
    <string name="ext_media_seamless_action" msgid="8837030226009268080">"Prebacite izlaz"</string>
    <string name="ext_media_missing_title" msgid="3209472091220515046">"<xliff:g id="NAME">%s</xliff:g> nedostaje"</string>
    <string name="ext_media_missing_message" msgid="4408988706227922909">"Ponovo umetnite uređaj"</string>
    <string name="ext_media_move_specific_title" msgid="8492118544775964250">"Premješta se <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_title" msgid="2682741525619033637">"Premještanje podataka"</string>
    <string name="ext_media_move_success_title" msgid="4901763082647316767">"Prijenos sadržaja je završen"</string>
    <string name="ext_media_move_success_message" msgid="9159542002276982979">"Sadržaj je premješten na uređaj <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_failure_title" msgid="3184577479181333665">"Nije moguće premjestiti sadržaj"</string>
    <string name="ext_media_move_failure_message" msgid="4197306718121869335">"Pokušajte ponovo premjestiti sadržaj"</string>
    <string name="ext_media_status_removed" msgid="241223931135751691">"Uređaj je uklonjen"</string>
    <string name="ext_media_status_unmounted" msgid="8145812017295835941">"Uređaj je izbačen"</string>
    <string name="ext_media_status_checking" msgid="159013362442090347">"Provjerava se..."</string>
    <string name="ext_media_status_mounted" msgid="3459448555811203459">"Uređaj je spreman"</string>
    <string name="ext_media_status_mounted_ro" msgid="1974809199760086956">"Samo za čitanje"</string>
    <string name="ext_media_status_bad_removal" msgid="508448566481406245">"Uređaj je uklonjen na nebezbjedan način"</string>
    <string name="ext_media_status_unmountable" msgid="7043574843541087748">"Uređaj je oštećen"</string>
    <string name="ext_media_status_unsupported" msgid="5460509911660539317">"Uređaj nije podržan"</string>
    <string name="ext_media_status_ejecting" msgid="7532403368044013797">"Izbacuje se..."</string>
    <string name="ext_media_status_formatting" msgid="774148701503179906">"Formatira se..."</string>
    <string name="ext_media_status_missing" msgid="6520746443048867314">"Uređaj nije ubačen"</string>
    <string name="activity_list_empty" msgid="4219430010716034252">"Nije pronađena nijedna odgovarajuća aktivnost."</string>
    <string name="permlab_route_media_output" msgid="8048124531439513118">"usmjeravanje izlaza za medijske fajlove"</string>
    <string name="permdesc_route_media_output" msgid="1759683269387729675">"Omogućava aplikaciji usmjeravanje izlaza sa medija na druge vanjske uređaje."</string>
    <string name="permlab_readInstallSessions" msgid="7279049337895583621">"čitanje sesija instaliranja"</string>
    <string name="permdesc_readInstallSessions" msgid="4012608316610763473">"Dozvoljava aplikaciji da čita sesije instalacija. Ovim se aplikaciji omogućava da vidi detalje o aktivnim instalacijama paketa."</string>
    <string name="permlab_requestInstallPackages" msgid="7600020863445351154">"zahtijevanje paketa za instaliranje"</string>
    <string name="permdesc_requestInstallPackages" msgid="3969369278325313067">"Omogućava aplikaciji da zahtijeva instalaciju paket ā."</string>
    <string name="permlab_requestDeletePackages" msgid="2541172829260106795">"zatraži brisanje paketanja"</string>
    <string name="permdesc_requestDeletePackages" msgid="6133633516423860381">"Omogućava aplikaciji da zatraži brisanje paketa."</string>
    <string name="permlab_requestIgnoreBatteryOptimizations" msgid="7646611326036631439">"traži zanemarivanje optimizacije baterije"</string>
    <string name="permdesc_requestIgnoreBatteryOptimizations" msgid="634260656917874356">"Omogućava aplikaciji da traži odobrenje za zanemarivanje optimizacije baterije za tu aplikaciju."</string>
    <string name="permlab_queryAllPackages" msgid="2928450604653281650">"upit za sve pakete"</string>
    <string name="permdesc_queryAllPackages" msgid="5339069855520996010">"Omogućava aplikaciji da pregleda sve instalirane pakete."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="1842872462124648678">"Dodirnite dvaput za kontrolu uvećanja"</string>
    <string name="gadget_host_error_inflating" msgid="2449961590495198720">"Dodavanje vidžeta nije uspjelo."</string>
    <string name="ime_action_go" msgid="5536744546326495436">"Započni"</string>
    <string name="ime_action_search" msgid="4501435960587287668">"Pretraži"</string>
    <string name="ime_action_send" msgid="8456843745664334138">"Poslati"</string>
    <string name="ime_action_next" msgid="4169702997635728543">"Naprijed"</string>
    <string name="ime_action_done" msgid="6299921014822891569">"Gotovo"</string>
    <string name="ime_action_previous" msgid="6548799326860401611">"Naz."</string>
    <string name="ime_action_default" msgid="8265027027659800121">"Izvrši"</string>
    <string name="dial_number_using" msgid="6060769078933953531">"Biraj\nbroj <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="6200708808003692594">"Napraviti kontakt\nkoristeći broj <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="5365733888842570481">"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="1886710210516246461">"Želite li dozvoliti taj zahtjev?"</string>
    <string name="grant_permissions_header_text" msgid="3420736827804657201">"Zahtjev za pristup"</string>
    <string name="allow" msgid="6195617008611933762">"Dozvoli"</string>
    <string name="deny" msgid="6632259981847676572">"Odbij"</string>
    <string name="permission_request_notification_title" msgid="1810025922441048273">"Upućen zahtjev za odobrenje"</string>
    <string name="permission_request_notification_with_subtitle" msgid="3743417870360129298">"Upućen zahtjev za dozvolu\nza račun <xliff:g id="ACCOUNT">%s</xliff:g>."</string>
    <string name="permission_request_notification_for_app_with_subtitle" msgid="1298704005732851350">"Odobrenje je zatražila aplikacija <xliff:g id="APP">%1$s</xliff:g>\nza račun <xliff:g id="ACCOUNT">%2$s</xliff:g>."</string>
    <string name="forward_intent_to_owner" msgid="4620359037192871015">"Aplikaciju koristite van poslovnog profila"</string>
    <string name="forward_intent_to_work" msgid="3620262405636021151">"Aplikaciju koristite u poslovnom profilu"</string>
    <string name="input_method_binding_label" msgid="1166731601721983656">"Način unosa"</string>
    <string name="sync_binding_label" msgid="469249309424662147">"Sinhrona"</string>
    <string name="accessibility_binding_label" msgid="1974602776545801715">"Pristupačnost"</string>
    <string name="wallpaper_binding_label" msgid="1197440498000786738">"Pozadinska slika"</string>
    <string name="chooser_wallpaper" msgid="3082405680079923708">"Promijenite pozadinsku sliku"</string>
    <string name="notification_listener_binding_label" msgid="2702165274471499713">"Usluga za praćenje obavještenja"</string>
    <string name="vr_listener_binding_label" msgid="8013112996671206429">"VR slušalac"</string>
    <string name="condition_provider_service_binding_label" msgid="8490641013951857673">"Pružalac uslova"</string>
    <string name="notification_ranker_binding_label" msgid="432708245635563763">"Usluga rangiranja obavještenja"</string>
    <string name="vpn_title" msgid="5906991595291514182">"VPN aktiviran"</string>
    <string name="vpn_title_long" msgid="6834144390504619998">"Aplikacija <xliff:g id="APP">%s</xliff:g> je aktivirala VPN"</string>
    <string name="vpn_text" msgid="2275388920267251078">"Dodirnite da upravljate mrežom."</string>
    <string name="vpn_text_long" msgid="278540576806169831">"Povezano sa sesijom <xliff:g id="SESSION">%s</xliff:g>. Dodirnite da upravljate mrežom."</string>
    <string name="vpn_lockdown_connecting" msgid="6096725311950342607">"Povezivanje na uvijek aktivni VPN…"</string>
    <string name="vpn_lockdown_connected" msgid="2853127976590658469">"Povezan na uvijek aktivni VPN"</string>
    <string name="vpn_lockdown_disconnected" msgid="5573611651300764955">"Prekinuta je veza s uvijek uključenim VPN-om"</string>
    <string name="vpn_lockdown_error" msgid="4453048646854247947">"Povezivanje na stalno uključen VPN nije uspjelo na stalno uključen VPN"</string>
    <string name="vpn_lockdown_config" msgid="8331697329868252169">"Promijenite postavke mreže ili VPN-a"</string>
    <string name="upload_file" msgid="8651942222301634271">"Odabir fajla"</string>
    <string name="no_file_chosen" msgid="4146295695162318057">"Nije izabran nijedan fajl"</string>
    <string name="reset" msgid="3865826612628171429">"Vrati na zadano"</string>
    <string name="submit" msgid="862795280643405865">"Potvrdi"</string>
    <string name="car_mode_disable_notification_title" msgid="8450693275833142896">"Aplikacija za vožnju je pokrenuta"</string>
    <string name="car_mode_disable_notification_message" msgid="8954550232288567515">"Dodirnite za izlaz iz aplikacije za vožnju."</string>
    <string name="back_button_label" msgid="4078224038025043387">"Nazad"</string>
    <string name="next_button_label" msgid="6040209156399907780">"Naprijed"</string>
    <string name="skip_button_label" msgid="3566599811326688389">"Preskoči"</string>
    <string name="no_matches" msgid="6472699895759164599">"Nema podudaranja"</string>
    <string name="find_on_page" msgid="5400537367077438198">"Pronađi na stranici"</string>
    <string name="matches_found" msgid="2296462299979507689">"{count,plural, =1{# podudaranje}one{# od ukupno {total}}few{# od ukupno {total}}other{# od ukupno {total}}}"</string>
    <string name="action_mode_done" msgid="2536182504764803222">"Gotovo"</string>
    <string name="progress_erasing" msgid="6891435992721028004">"Brisanje dijeljene pohrane…"</string>
    <string name="share" msgid="4157615043345227321">"Dijeli"</string>
    <string name="find" msgid="5015737188624767706">"Pronađi"</string>
    <string name="websearch" msgid="5624340204512793290">"Internet pretraživanje"</string>
    <string name="find_next" msgid="5341217051549648153">"Nađi sljedeći"</string>
    <string name="find_previous" msgid="4405898398141275532">"Nađi prethodni"</string>
    <string name="gpsNotifTicker" msgid="3207361857637620780">"Korisnik <xliff:g id="NAME">%s</xliff:g> je poslao zahtjev za utvrđivanje lokacije"</string>
    <string name="gpsNotifTitle" msgid="1590033371665669570">"Zahtjev za lokaciju"</string>
    <string name="gpsNotifMessage" msgid="7346649122793758032">"Zahtjev uputio <xliff:g id="NAME">%1$s</xliff:g> (<xliff:g id="SERVICE">%2$s</xliff:g>)"</string>
    <string name="gpsVerifYes" msgid="3719843080744112940">"Da"</string>
    <string name="gpsVerifNo" msgid="1671201856091564741">"Ne"</string>
    <string name="sync_too_many_deletes" msgid="6999440774578705300">"Granica za brisanje prekoračena"</string>
    <string name="sync_too_many_deletes_desc" msgid="7409327940303504440">"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="5657871730315579051">"Izbriši stavke"</string>
    <string name="sync_undo_deletes" msgid="5786033331266418896">"Poništiti brisanje"</string>
    <string name="sync_do_nothing" msgid="4528734662446469646">"Ne radi ništa za sada"</string>
    <string name="choose_account_label" msgid="5557833752759831548">"Odaberite račun"</string>
    <string name="add_account_label" msgid="4067610644298737417">"Dodaj račun"</string>
    <string name="add_account_button_label" msgid="322390749416414097">"Dodajte račun"</string>
    <string name="number_picker_increment_button" msgid="7621013714795186298">"Povećaj"</string>
    <string name="number_picker_decrement_button" msgid="5116948444762708204">"Smanji"</string>
    <string name="number_picker_increment_scroll_mode" msgid="8403893549806805985">"<xliff:g id="VALUE">%s</xliff:g> dodirnite i držite."</string>
    <string name="number_picker_increment_scroll_action" msgid="8310191318914268271">"Kliznite gore da povećate i dolje da smanjite."</string>
    <string name="time_picker_increment_minute_button" msgid="7195870222945784300">"Povećaj minute"</string>
    <string name="time_picker_decrement_minute_button" msgid="230925389943411490">"Smanji minute"</string>
    <string name="time_picker_increment_hour_button" msgid="3063572723197178242">"Povećaj sate"</string>
    <string name="time_picker_decrement_hour_button" msgid="584101766855054412">"Smanji sate"</string>
    <string name="time_picker_increment_set_pm_button" msgid="5889149366900376419">"Postavi za poslijepodne (PM)"</string>
    <string name="time_picker_decrement_set_am_button" msgid="1422608001541064087">"Postavi za prijepodne"</string>
    <string name="date_picker_increment_month_button" msgid="3447263316096060309">"Povećaj mjesece"</string>
    <string name="date_picker_decrement_month_button" msgid="6531888937036883014">"Smanji mjesece"</string>
    <string name="date_picker_increment_day_button" msgid="4349336637188534259">"Povećaj dane"</string>
    <string name="date_picker_decrement_day_button" msgid="6840253837656637248">"Smanji dane"</string>
    <string name="date_picker_increment_year_button" msgid="7608128783435372594">"Povećaj godine"</string>
    <string name="date_picker_decrement_year_button" msgid="4102586521754172684">"Smanji godine"</string>
    <string name="date_picker_prev_month_button" msgid="3418694374017868369">"Prethodni mjesec"</string>
    <string name="date_picker_next_month_button" msgid="4858207337779144840">"Sljedeći mjesec"</string>
    <string name="keyboardview_keycode_alt" msgid="8997420058584292385">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="2134624484115716975">"Otkaži"</string>
    <string name="keyboardview_keycode_delete" msgid="2661117313730098650">"Izbriši"</string>
    <string name="keyboardview_keycode_done" msgid="2524518019001653851">"Gotovo"</string>
    <string name="keyboardview_keycode_mode_change" msgid="2743735349997999020">"Promjena načina rada"</string>
    <string name="keyboardview_keycode_shift" msgid="3026509237043975573">"Shift"</string>
    <string name="keyboardview_keycode_enter" msgid="168054869339091055">"Potvrdi"</string>
    <string name="activitychooserview_choose_application" msgid="3500574466367891463">"Odaberite aplikaciju"</string>
    <string name="activitychooserview_choose_application_error" msgid="6937782107559241734">"Aplikacija <xliff:g id="APPLICATION_NAME">%s</xliff:g> se ne može pokrenuti."</string>
    <string name="shareactionprovider_share_with" msgid="2753089758467748982">"Podijeliti sa"</string>
    <string name="shareactionprovider_share_with_application" msgid="4902832247173666973">"Dijeli pomoću aplikacije <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="982510275422590757">"Klizni regulator. Dodirnite &amp; držite."</string>
    <string name="description_target_unlock_tablet" msgid="7431571180065859551">"Prevucite za otključavanje ekrana."</string>
    <string name="action_bar_home_description" msgid="1501655419158631974">"Vratite se na početnu stranicu"</string>
    <string name="action_bar_up_description" msgid="6611579697195026932">"Navigirajte prema gore"</string>
    <string name="action_menu_overflow_description" msgid="4579536843510088170">"Više opcija"</string>
    <string name="action_bar_home_description_format" msgid="5087107531331621803">"%1$s, %2$s"</string>
    <string name="action_bar_home_subtitle_description_format" msgid="4346835454749569826">"%1$s, %2$s, %3$s"</string>
    <string name="storage_internal" msgid="8490227947584914460">"Interno dijeljena pohrana"</string>
    <string name="storage_sd_card" msgid="3404740277075331881">"SD kartica"</string>
    <string name="storage_sd_card_label" msgid="7526153141147470509">"<xliff:g id="MANUFACTURER">%s</xliff:g> SD kartica"</string>
    <string name="storage_usb_drive" msgid="448030813201444573">"USB disk"</string>
    <string name="storage_usb_drive_label" msgid="6631740655876540521">"<xliff:g id="MANUFACTURER">%s</xliff:g> USB disk"</string>
    <string name="storage_usb" msgid="2391213347883616886">"USB pohrana"</string>
    <string name="extract_edit_menu_button" msgid="63954536535863040">"Uredi"</string>
    <string name="data_usage_warning_title" msgid="9034893717078325845">"Upozorenje o prijenosu podataka"</string>
    <string name="data_usage_warning_body" msgid="1669325367188029454">"Potrošili ste <xliff:g id="APP">%s</xliff:g> podataka"</string>
    <string name="data_usage_mobile_limit_title" msgid="3911447354393775241">"Dostignuto ograničenje za prijenos podataka"</string>
    <string name="data_usage_wifi_limit_title" msgid="2069698056520812232">"Dostignut limit WiFi podataka"</string>
    <string name="data_usage_limit_body" msgid="3567699582000085710">"Prijenos podataka je pauziran do kraja ciklusa"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="101888478915677895">"Pređen limit mobilnih podataka"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="1622359254521960508">"Prekoračen limit WiFi podataka"</string>
    <string name="data_usage_limit_snoozed_body" msgid="545146591766765678">"Prekoračili ste postavljeni limit od <xliff:g id="SIZE">%s</xliff:g>"</string>
    <string name="data_usage_restricted_title" msgid="126711424380051268">"Pozadinski podaci su ograničeni"</string>
    <string name="data_usage_restricted_body" msgid="5338694433686077733">"Dodirnite da biste uklonili ograničenja."</string>
    <string name="data_usage_rapid_title" msgid="2950192123248740375">"Velika potrošnja mobil. podataka"</string>
    <string name="data_usage_rapid_body" msgid="3886676853263693432">"Vaše aplikacije su potrošile više podataka nego obično"</string>
    <string name="data_usage_rapid_app_body" msgid="5425779218506513861">"Aplikacija <xliff:g id="APP">%s</xliff:g> je potrošila više podataka nego obično"</string>
    <string name="ssl_certificate" msgid="5690020361307261997">"Sigurnosni certifikat"</string>
    <string name="ssl_certificate_is_valid" msgid="7293675884598527081">"Ovaj certifikat je važeći."</string>
    <string name="issued_to" msgid="5975877665505297662">"Primalac:"</string>
    <string name="common_name" msgid="1486334593631798443">"Ime domene:"</string>
    <string name="org_name" msgid="7526331696464255245">"Organizacija:"</string>
    <string name="org_unit" msgid="995934486977223076">"Organizaciona jedinica:"</string>
    <string name="issued_by" msgid="7872459822431585684">"Izdao:"</string>
    <string name="validity_period" msgid="1717724283033175968">"Valjanost:"</string>
    <string name="issued_on" msgid="5855489688152497307">"Datum izdavanja:"</string>
    <string name="expires_on" msgid="1623640879705103121">"Ističe:"</string>
    <string name="serial_number" msgid="3479576915806623429">"Serijski broj:"</string>
    <string name="fingerprints" msgid="148690767172613723">"Otisci prstiju:"</string>
    <string name="sha256_fingerprint" msgid="7103976380961964600">"SHA-256 otisak prsta:"</string>
    <string name="sha1_fingerprint" msgid="2339915142825390774">"SHA-1 otisak prsta:"</string>
    <string name="activity_chooser_view_see_all" msgid="3917045206812726099">"Prikaži sve"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="8880731437191978314">"Odaberite aktivnost"</string>
    <string name="share_action_provider_share_with" msgid="1904096863622941880">"Podijeliti sa"</string>
    <string name="sending" msgid="206925243621664438">"Slanje..."</string>
    <string name="launchBrowserDefault" msgid="6328349989932924119">"Pokretanje preglednika?"</string>
    <string name="SetupCallDefault" msgid="5581740063237175247">"Prihvatiti poziv?"</string>
    <string name="activity_resolver_use_always" msgid="5575222334666843269">"Uvijek"</string>
    <string name="activity_resolver_use_once" msgid="948462794469672658">"Samo ovaj put"</string>
    <string name="activity_resolver_work_profiles_support" msgid="4071345609235361269">"%1$s ne podržava poslovni profil"</string>
    <string name="default_audio_route_name" product="tablet" msgid="367936735632195517">"Tablet"</string>
    <string name="default_audio_route_name" product="tv" msgid="4908971385068087367">"TV"</string>
    <string name="default_audio_route_name" product="default" msgid="9213546147739983977">"Telefon"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="1551166029093995289">"Zvučnici priključne stanice"</string>
    <string name="default_audio_route_name_hdmi" msgid="5474470558160717850">"HDMI"</string>
    <string name="default_audio_route_name_headphones" msgid="6954070994792640762">"Slušalice"</string>
    <string name="default_audio_route_name_usb" msgid="895668743163316932">"USB"</string>
    <string name="default_audio_route_category_name" msgid="5241740395748134483">"Sistem"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="4214648773120426288">"Bluetooth audio"</string>
    <string name="wireless_display_route_description" msgid="8297563323032966831">"Bežični prikaz"</string>
    <string name="media_route_button_content_description" msgid="2299223698196869956">"Emitiranje"</string>
    <string name="media_route_chooser_title" msgid="6646594924991269208">"Poveži na uređaj"</string>
    <string name="media_route_chooser_title_for_remote_display" msgid="3105906508794326446">"Emitiranje ekrana na uređaj"</string>
    <string name="media_route_chooser_searching" msgid="6119673534251329535">"Traženje uređaja…"</string>
    <string name="media_route_chooser_extended_settings" msgid="2506352159381327741">"Postavke"</string>
    <string name="media_route_controller_disconnect" msgid="7362617572732576959">"Prekini vezu"</string>
    <string name="media_route_status_scanning" msgid="8045156315309594482">"Skeniranje…"</string>
    <string name="media_route_status_connecting" msgid="5845597961412010540">"Povezivanje…"</string>
    <string name="media_route_status_available" msgid="1477537663492007608">"Dostupno"</string>
    <string name="media_route_status_not_available" msgid="480912417977515261">"Nije dostupno"</string>
    <string name="media_route_status_in_use" msgid="6684112905244944724">"U upotrebi"</string>
    <string name="display_manager_built_in_display_name" msgid="1015775198829722440">"Ugrađeni ekran"</string>
    <string name="display_manager_hdmi_display_name" msgid="1022758026251534975">"HDMI ekran"</string>
    <string name="display_manager_overlay_display_name" msgid="5306088205181005861">"Nadsloj #<xliff:g id="ID">%1$d</xliff:g>"</string>
    <string name="display_manager_overlay_display_title" msgid="1480158037150469170">"<xliff:g id="NAME">%1$s</xliff:g>: <xliff:g id="WIDTH">%2$d</xliff:g>x<xliff:g id="HEIGHT">%3$d</xliff:g>, <xliff:g id="DPI">%4$d</xliff:g> dpi"</string>
    <string name="display_manager_overlay_display_secure_suffix" msgid="2810034719482834679">", osigurano"</string>
    <string name="kg_forgot_pattern_button_text" msgid="406145459223122537">"Zaboravili ste uzorak?"</string>
    <string name="kg_wrong_pattern" msgid="1342812634464179931">"Pogrešan uzorak"</string>
    <string name="kg_wrong_password" msgid="2384677900494439426">"Pogrešna lozinka"</string>
    <string name="kg_wrong_pin" msgid="3680925703673166482">"Pogrešan PIN"</string>
    <string name="kg_pattern_instructions" msgid="8366024510502517748">"Nacrtajte obrazac"</string>
    <string name="kg_sim_pin_instructions" msgid="6479401489471690359">"Unesite PIN za SIM"</string>
    <string name="kg_pin_instructions" msgid="7355933174673539021">"Unesite PIN"</string>
    <string name="kg_password_instructions" msgid="7179782578809398050">"Unesite lozinku"</string>
    <string name="kg_puk_enter_puk_hint" msgid="6696187482616360994">"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="8190982314659429770">"Unesite željeni PIN"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="6372557107414074580">"Potvrdi željeni PIN"</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8871937892678885545">"Otključavanje SIM kartice…"</string>
    <string name="kg_password_wrong_pin_code" msgid="9013856346870572451">"Pogrešan PIN."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="4821601451222564077">"Unesite PIN koji sadrži od 4 do 8 brojeva."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="2539364558870734339">"PUK kôd bi trebao imati 8 brojeva."</string>
    <string name="kg_invalid_puk" msgid="4809502818518963344">"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="4705368340409816254">"PIN-ovi se ne poklapaju"</string>
    <string name="kg_login_too_many_attempts" msgid="699292728290654121">"Previše pokušaja otključavanja pomoću uzorka"</string>
    <string name="kg_login_instructions" msgid="3619844310339066827">"Da otključate, prijavite se pomoću svog Google računa."</string>
    <string name="kg_login_username_hint" msgid="1765453775467133251">"Korisničko ime (adresa e-pošte)"</string>
    <string name="kg_login_password_hint" msgid="3330530727273164402">"Lozinka"</string>
    <string name="kg_login_submit_button" msgid="893611277617096870">"Prijava"</string>
    <string name="kg_login_invalid_input" msgid="8292367491901220210">"Pogrešno korisničko ime ili lozinka."</string>
    <string name="kg_login_account_recovery_hint" msgid="4892466171043541248">"Zaboravili ste korisničko ime ili lozinku?\nPosjetite "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="kg_login_checking_password" msgid="4676010303243317253">"Provjeravanje računa…"</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="23741434207544038">"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="3328686432962224215">"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="7357404233979139075">"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="3479940221343361587">"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="9064457748587850217">"Pokušali ste neispravno otključati Android TV uređaj <xliff:g id="NUMBER_0">%1$d</xliff:g> put(a). U slučaju još <xliff:g id="NUMBER_1">%2$d</xliff:g> pokušaja bez uspjeha, vaš Android TV će se vratiti na fabričke postavke i svi korisnički podaci će biti izgubljeni."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="5955398963754432548">"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="2299099385175083308">"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="5045460916106267585">"Pokušali ste neispravno otključati Android TV uređaj <xliff:g id="NUMBER">%d</xliff:g> put(a). Vaš Android TV uređaj će se sada vratiti na fabričke postavke."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="5043730590446071189">"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="7086799295109717623">"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="4670840383567106114">"Uzorak za otključavanje ste pogrešno nacrtali <xliff:g id="NUMBER_0">%1$d</xliff:g> put(a). U slučaju još <xliff:g id="NUMBER_1">%2$d</xliff:g> pokušaja bez uspjeha, od vas će se tražiti da otključate Android TV uređaj pomoću računa 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="default" msgid="5270861875006378092">"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="4503708889934976866">" — "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="2034358143731750914">"Ukloni"</string>
    <string name="safe_media_volume_warning" product="default" msgid="3751676824423049994">"Ž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="4017995837692622933">"Želite li koristiti Prečicu za pristupačnost?"</string>
    <string name="accessibility_shortcut_toogle_warning" msgid="4161716521310929544">"Kada je prečica uključena, pritiskom i držanjem oba dugmeta za jačinu zvuka u trajanju od 3 sekunde pokrenut će se funkcija pristupačnosti."</string>
    <string name="accessibility_shortcut_multiple_service_warning_title" msgid="3135860819356676426">"Uključiti prečicu za funkcije pristupačnosti?"</string>
    <string name="accessibility_shortcut_multiple_service_warning" msgid="3740723309483706911">"Ako nekoliko sekundi držite pritisnute obje tipke za jačinu zvuka, uključit ćete funkcije pristupačnosti. Ovo može uticati na način rada uređaja.\n\nTrenutne funkcije:\n<xliff:g id="SERVICE">%1$s</xliff:g>\nOdabrane funkcije možete promijeniti u odjeljku Postavke &gt; Pristupačnost."</string>
    <string name="accessibility_shortcut_multiple_service_list" msgid="2128323171922023762">" • <xliff:g id="SERVICE">%1$s</xliff:g>\n"</string>
    <string name="accessibility_shortcut_single_service_warning_title" msgid="1909518473488345266">"Uključiti prečicu za uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_shortcut_single_service_warning" msgid="6363127705112844257">"Ako nekoliko sekundi držite pritisnute obje tipke za jačinu zvuka, uključit ćete funkciju pristupačnosti <xliff:g id="SERVICE">%1$s</xliff:g>. Ovo može promijeniti način rada uređaja.\n\nOvu prečicu možete zamijeniti drugom funkcijom u odjeljku Postavke &gt; Pristupačnost."</string>
    <string name="accessibility_shortcut_on" msgid="5463618449556111344">"Uključi"</string>
    <string name="accessibility_shortcut_off" msgid="3651336255403648739">"Nemoj uključiti"</string>
    <string name="accessibility_shortcut_menu_item_status_on" msgid="6608392117189732543">"UKLJUČENO"</string>
    <string name="accessibility_shortcut_menu_item_status_off" msgid="5531598275559472393">"ISKLJUČENO"</string>
    <string name="accessibility_enable_service_title" msgid="3931558336268541484">"Dozvoliti da usluga <xliff:g id="SERVICE">%1$s</xliff:g> ima punu kontrolu nad vašim uređajem?"</string>
    <string name="accessibility_service_warning_description" msgid="291674995220940133">"Puna kontrola je prikladna za aplikacije koje vam pomažu kod potreba pristupačnosti, ali nije za većinu aplikacija."</string>
    <string name="accessibility_service_screen_control_title" msgid="190017412626919776">"Prikaz i kontrola ekrana"</string>
    <string name="accessibility_service_screen_control_description" msgid="6946315917771791525">"Može čitati sav sadržaj na ekranu i prikazivati sadržaj preko drugih aplikacija."</string>
    <string name="accessibility_service_action_perform_title" msgid="779670378951658160">"Prikaz i izvršavanje radnji"</string>
    <string name="accessibility_service_action_perform_description" msgid="2718852014003170558">"Može pratiti vaše interakcije s aplikacijom ili hardverskim senzorom te ostvariti interakciju s aplikacijama umjesto vas."</string>
    <string name="accessibility_dialog_button_allow" msgid="2092558122987144530">"Dozvoli"</string>
    <string name="accessibility_dialog_button_deny" msgid="4129575637812472671">"Odbij"</string>
    <string name="accessibility_select_shortcut_menu_title" msgid="6002726538854613272">"Dodirnite funkciju da je počnete koristiti:"</string>
    <string name="accessibility_edit_shortcut_menu_button_title" msgid="239446795930436325">"Odaberite funkcije koje ćete koristiti s dugmetom Pristupačnost"</string>
    <string name="accessibility_edit_shortcut_menu_volume_title" msgid="1077294237378645981">"Odaberite funkcije koje ćete koristiti pomoću prečice tipke za jačinu zvuka"</string>
    <string name="accessibility_uncheck_legacy_item_warning" msgid="8047830891064817447">"Usluga <xliff:g id="SERVICE_NAME">%s</xliff:g> je isključena"</string>
    <string name="edit_accessibility_shortcut_menu_button" msgid="8885752738733772935">"Uredi prečice"</string>
    <string name="done_accessibility_shortcut_menu_button" msgid="3668407723770815708">"Gotovo"</string>
    <string name="disable_accessibility_shortcut" msgid="5806091378745232383">"Isključi prečicu"</string>
    <string name="leave_accessibility_shortcut_on" msgid="6543362062336990814">"Koristi prečicu"</string>
    <string name="color_inversion_feature_name" msgid="326050048927789012">"Inverzija boja"</string>
    <string name="color_correction_feature_name" msgid="3655077237805422597">"Ispravka boja"</string>
    <string name="one_handed_mode_feature_name" msgid="2334330034828094891">"Način rada jednom rukom"</string>
    <string name="reduce_bright_colors_feature_name" msgid="3222994553174604132">"Dodatno zatamnjeno"</string>
    <string name="accessibility_shortcut_enabling_service" msgid="5473495203759847687">"Držali ste tipke za jačinu zvuka. Usluga <xliff:g id="SERVICE_NAME">%1$s</xliff:g> je uključena."</string>
    <string name="accessibility_shortcut_disabling_service" msgid="8675244165062700619">"Držali ste tipke za jačinu zvuka. Usluga <xliff:g id="SERVICE_NAME">%1$s</xliff:g> je isključena."</string>
    <string name="accessibility_shortcut_spoken_feedback" msgid="4228997042855695090">"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="8343213623338605305">"Odaberite funkciju koja će se koristiti kada dodirnete dugme Pristupačnost:"</string>
    <string name="accessibility_gesture_prompt_text" msgid="8742535972130563952">"Odaberite funkciju koju ćete 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="5211827854510660203">"Odaberite funkciju koju ćete koristiti kada izvedete pokret za pristupačnost (s tri prsta prevucite prema gore s dna ekrana):"</string>
    <string name="accessibility_button_instructional_text" msgid="8853928358872550500">"Za prebacivanje između funkcija, dodirnite i zadržite dugme Pristupačnost."</string>
    <string name="accessibility_gesture_instructional_text" msgid="9196230728837090497">"Da prebacujete između funkcija, s dva prsta prevucite prema gore i zadržite."</string>
    <string name="accessibility_gesture_3finger_instructional_text" msgid="3425123684990193765">"Da prebacujete između funkcija, s tri prsta prevucite prema gore i zadržite."</string>
    <string name="accessibility_magnification_chooser_text" msgid="1502075582164931596">"Uvećavanje"</string>
    <string name="user_switched" msgid="7249833311585228097">"Trenutni korisnik <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="user_switching_message" msgid="1912993630661332336">"Prebacivanje na korisnika <xliff:g id="NAME">%1$s</xliff:g>..."</string>
    <string name="user_logging_out_message" msgid="7216437629179710359">"Odjava korisnika <xliff:g id="NAME">%1$s</xliff:g>…"</string>
    <string name="owner_name" msgid="8713560351570795743">"Vlasnik"</string>
    <string name="guest_name" msgid="8502103277839834324">"Gost"</string>
    <string name="error_message_title" msgid="4082495589294631966">"Greška"</string>
    <string name="error_message_change_not_allowed" msgid="843159705042381454">"Vaš administrator ne dozvoljava ovu promjenu"</string>
    <string name="app_not_found" msgid="3429506115332341800">"Nije pronađena aplikacija koja će upravljati ovom akcijom."</string>
    <string name="revoke" msgid="5526857743819590458">"Opozovi"</string>
    <string name="mediasize_iso_a0" msgid="7039061159929977973">"ISO A0"</string>
    <string name="mediasize_iso_a1" msgid="4063589931031977223">"ISO A1"</string>
    <string name="mediasize_iso_a2" msgid="2779860175680233980">"ISO A2"</string>
    <string name="mediasize_iso_a3" msgid="3683469257246970630">"ISO A3"</string>
    <string name="mediasize_iso_a4" msgid="752903572302658845">"ISO A4"</string>
    <string name="mediasize_iso_a5" msgid="3020439171949376572">"ISO A5"</string>
    <string name="mediasize_iso_a6" msgid="6503671662530738180">"ISO A6"</string>
    <string name="mediasize_iso_a7" msgid="8488649018955763878">"ISO A7"</string>
    <string name="mediasize_iso_a8" msgid="3380506944389571030">"ISO A8"</string>
    <string name="mediasize_iso_a9" msgid="7000627318995334730">"ISO A9"</string>
    <string name="mediasize_iso_a10" msgid="4091511972200388310">"ISO A10"</string>
    <string name="mediasize_iso_b0" msgid="2057859571254103889">"ISO B0"</string>
    <string name="mediasize_iso_b1" msgid="4931975244795236924">"ISO B1"</string>
    <string name="mediasize_iso_b2" msgid="4701978611340339483">"ISO B2"</string>
    <string name="mediasize_iso_b3" msgid="3509735449039761603">"ISO B3"</string>
    <string name="mediasize_iso_b4" msgid="486628178454656526">"ISO B4"</string>
    <string name="mediasize_iso_b5" msgid="2507554073053511267">"ISO B5"</string>
    <string name="mediasize_iso_b6" msgid="344189428571954711">"ISO B6"</string>
    <string name="mediasize_iso_b7" msgid="7266158663658064799">"ISO B7"</string>
    <string name="mediasize_iso_b8" msgid="5229204010533786299">"ISO B8"</string>
    <string name="mediasize_iso_b9" msgid="2925910409602493256">"ISO B9"</string>
    <string name="mediasize_iso_b10" msgid="8590530019536996218">"ISO B10"</string>
    <string name="mediasize_iso_c0" msgid="6504734131385460314">"ISO C0"</string>
    <string name="mediasize_iso_c1" msgid="1751671704929443684">"ISO C1"</string>
    <string name="mediasize_iso_c2" msgid="2935473413647925667">"ISO C2"</string>
    <string name="mediasize_iso_c3" msgid="6835637985527663396">"ISO C3"</string>
    <string name="mediasize_iso_c4" msgid="3000965043023118958">"ISO C4"</string>
    <string name="mediasize_iso_c5" msgid="3846339505379333795">"ISO C5"</string>
    <string name="mediasize_iso_c6" msgid="8663097559661858303">"ISO C6"</string>
    <string name="mediasize_iso_c7" msgid="4469290754678239705">"ISO C7"</string>
    <string name="mediasize_iso_c8" msgid="1949330679635319183">"ISO C8"</string>
    <string name="mediasize_iso_c9" msgid="3716843356839880581">"ISO C9"</string>
    <string name="mediasize_iso_c10" msgid="2113667674722450076">"ISO C10"</string>
    <string name="mediasize_na_letter" msgid="1947253006814499213">"Letter"</string>
    <string name="mediasize_na_gvrnmt_letter" msgid="4056220626420245955">"Government Letter"</string>
    <string name="mediasize_na_legal" msgid="8356233803828931150">"Legal"</string>
    <string name="mediasize_na_junior_legal" msgid="3398084874757748531">"Junior Legal"</string>
    <string name="mediasize_na_ledger" msgid="1819497882853940248">"Ledger"</string>
    <string name="mediasize_na_tabloid" msgid="6792611672983574375">"Tabloid"</string>
    <string name="mediasize_na_index_3x5" msgid="990821038991491710">"Index Card 3x5"</string>
    <string name="mediasize_na_index_4x6" msgid="4414381976602032401">"Index Card 4x6"</string>
    <string name="mediasize_na_index_5x8" msgid="4499341583361946948">"Index Card 5x8"</string>
    <string name="mediasize_na_monarch" msgid="4396943937986136896">"Monarch"</string>
    <string name="mediasize_na_quarto" msgid="2119101847712239885">"Quarto"</string>
    <string name="mediasize_na_foolscap" msgid="5011612828564394648">"Foolscap"</string>
    <string name="mediasize_na_ansi_c" msgid="3104916921818289618">"ANSI C"</string>
    <string name="mediasize_na_ansi_d" msgid="254005964819282724">"ANSI D"</string>
    <string name="mediasize_na_ansi_e" msgid="4424174989686785675">"ANSI E"</string>
    <string name="mediasize_na_ansi_f" msgid="146980362213260987">"ANSI F"</string>
    <string name="mediasize_na_arch_a" msgid="5280681822380032361">"Arch A"</string>
    <string name="mediasize_na_arch_b" msgid="2113344093437297427">"Arch B"</string>
    <string name="mediasize_na_arch_c" msgid="971002546186856623">"Arch C"</string>
    <string name="mediasize_na_arch_d" msgid="6450996075335049806">"Arch D"</string>
    <string name="mediasize_na_arch_e" msgid="6782708486949266519">"Arch E"</string>
    <string name="mediasize_na_arch_e1" msgid="4707138568738504275">"Arch E1"</string>
    <string name="mediasize_na_super_b" msgid="6964127155618393178">"Super B"</string>
    <string name="mediasize_chinese_roc_8k" msgid="411670106572707544">"ROC 8K"</string>
    <string name="mediasize_chinese_roc_16k" msgid="7496706798725321898">"ROC 16K"</string>
    <string name="mediasize_chinese_prc_1" msgid="946949835711037253">"PRC 1"</string>
    <string name="mediasize_chinese_prc_2" msgid="4704308592895046237">"PRC 2"</string>
    <string name="mediasize_chinese_prc_3" msgid="1082996050478581675">"PRC 3"</string>
    <string name="mediasize_chinese_prc_4" msgid="7865122849174932948">"PRC 4"</string>
    <string name="mediasize_chinese_prc_5" msgid="852020506971633186">"PRC 5"</string>
    <string name="mediasize_chinese_prc_6" msgid="3399567254628077606">"PRC 6"</string>
    <string name="mediasize_chinese_prc_7" msgid="2804330751361491000">"PRC 7"</string>
    <string name="mediasize_chinese_prc_8" msgid="7988760621340084314">"PRC 8"</string>
    <string name="mediasize_chinese_prc_9" msgid="90266288020939533">"PRC 9"</string>
    <string name="mediasize_chinese_prc_10" msgid="7721316829399772162">"PRC 10"</string>
    <string name="mediasize_chinese_prc_16k" msgid="7471455177845043180">"PRC 16K"</string>
    <string name="mediasize_chinese_om_pa_kai" msgid="6305242012782587594">"Pa Kai"</string>
    <string name="mediasize_chinese_om_dai_pa_kai" msgid="8133982147973309032">"Dai Pa Kai"</string>
    <string name="mediasize_chinese_om_jurro_ku_kai" msgid="5888548906612445289">"Jurro Ku Kai"</string>
    <string name="mediasize_japanese_jis_b10" msgid="6761433476186549691">"JIS B10"</string>
    <string name="mediasize_japanese_jis_b9" msgid="6011047111717561836">"JIS B9"</string>
    <string name="mediasize_japanese_jis_b8" msgid="1541865115368043069">"JIS B8"</string>
    <string name="mediasize_japanese_jis_b7" msgid="8300341273885698803">"JIS B7"</string>
    <string name="mediasize_japanese_jis_b6" msgid="4329528623016980657">"JIS B6"</string>
    <string name="mediasize_japanese_jis_b5" msgid="7340334955358311979">"JIS B5"</string>
    <string name="mediasize_japanese_jis_b4" msgid="7403538361394953235">"JIS B4"</string>
    <string name="mediasize_japanese_jis_b3" msgid="9024287678505132047">"JIS B3"</string>
    <string name="mediasize_japanese_jis_b2" msgid="5151340021154579154">"JIS B2"</string>
    <string name="mediasize_japanese_jis_b1" msgid="2709589944170908250">"JIS B1"</string>
    <string name="mediasize_japanese_jis_b0" msgid="1209735840926222618">"JIS B0"</string>
    <string name="mediasize_japanese_jis_exec" msgid="2137738196058117115">"JIS Exec"</string>
    <string name="mediasize_japanese_chou4" msgid="2533204016634398713">"Chou4"</string>
    <string name="mediasize_japanese_chou3" msgid="5976745918096025459">"Chou3"</string>
    <string name="mediasize_japanese_chou2" msgid="6841260581434101675">"Chou2"</string>
    <string name="mediasize_japanese_hagaki" msgid="2112968853810337326">"Hagaki"</string>
    <string name="mediasize_japanese_oufuku" msgid="1575013107082530108">"Oufuku"</string>
    <string name="mediasize_japanese_kahu" msgid="7290232592648122042">"Kahu"</string>
    <string name="mediasize_japanese_kaku2" msgid="7477551750461028312">"Kaku2"</string>
    <string name="mediasize_japanese_you4" msgid="5552111912684384833">"You4"</string>
    <string name="mediasize_japanese_l" msgid="1326765321473431817">"L"</string>
    <string name="mediasize_unknown_portrait" msgid="3817016220446495613">"Neodređeni uspravni format"</string>
    <string name="mediasize_unknown_landscape" msgid="1584741567225095325">"Neodređeni vodoravni format"</string>
    <string name="write_fail_reason_cancelled" msgid="2344081488493969190">"Otkazano"</string>
    <string name="write_fail_reason_cannot_write" msgid="432118118378451508">"Greška pri pisanju sadržaja"</string>
    <string name="reason_unknown" msgid="5599739807581133337">"nepoznat"</string>
    <string name="reason_service_unavailable" msgid="5288405248063804713">"Usluga štampanja nije omogućena."</string>
    <string name="print_service_installed_title" msgid="6134880817336942482">"Usluga <xliff:g id="NAME">%s</xliff:g> je instalirana"</string>
    <string name="print_service_installed_message" msgid="7005672469916968131">"Dodirnite da omogućite"</string>
    <string name="restr_pin_enter_admin_pin" msgid="1199419462726962697">"Upišite PIN administratora"</string>
    <string name="restr_pin_enter_pin" msgid="373139384161304555">"Unesite PIN"</string>
    <string name="restr_pin_incorrect" msgid="3861383632940852496">"Netačno"</string>
    <string name="restr_pin_enter_old_pin" msgid="7537079094090650967">"Trenutni PIN"</string>
    <string name="restr_pin_enter_new_pin" msgid="3267614461844565431">"Novi PIN"</string>
    <string name="restr_pin_confirm_pin" msgid="7143161971614944989">"Potvrdi novi PIN"</string>
    <string name="restr_pin_create_pin" msgid="917067613896366033">"Kreiraj PIN za izmjenu ograničenja"</string>
    <string name="restr_pin_error_doesnt_match" msgid="7063392698489280556">"PIN-ovi se ne podudaraju. Pokušajte ponovo."</string>
    <string name="restr_pin_error_too_short" msgid="1547007808237941065">"PIN je prekratak. Mora imati najmanje 4 cifre."</string>
    <string name="restr_pin_try_later" msgid="5897719962541636727">"Pokušajte ponovo kasnije."</string>
    <string name="immersive_cling_title" msgid="2307034298721541791">"Prikazuje se cijeli ekran"</string>
    <string name="immersive_cling_description" msgid="7092737175345204832">"Da izađete, prevucite odozgo nadolje."</string>
    <string name="immersive_cling_positive" msgid="7047498036346489883">"Razumijem"</string>
    <string name="done_label" msgid="7283767013231718521">"Gotovo"</string>
    <string name="hour_picker_description" msgid="5153757582093524635">"Kružni klizač za odabir sata"</string>
    <string name="minute_picker_description" msgid="9029797023621927294">"Kružni klizač za minute"</string>
    <string name="select_hours" msgid="5982889657313147347">"Odaberite sat"</string>
    <string name="select_minutes" msgid="9157401137441014032">"Odaberite minute"</string>
    <string name="select_day" msgid="2060371240117403147">"Odaberite mjesec i dan"</string>
    <string name="select_year" msgid="1868350712095595393">"Odaberite godinu"</string>
    <string name="deleted_key" msgid="9130083334943364001">"Broj <xliff:g id="KEY">%1$s</xliff:g> je izbrisan"</string>
    <string name="managed_profile_label_badge" msgid="6762559569999499495">"Poslovni <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="managed_profile_label_badge_2" msgid="5673187309555352550">"2. poslovni <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="managed_profile_label_badge_3" msgid="6882151970556391957">"3. poslovni <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="lock_to_app_unlock_pin" msgid="3890940811866290782">"Traži PIN prije nego se otkači"</string>
    <string name="lock_to_app_unlock_pattern" msgid="2694204070499712503">"Traži uzorak za otključavanje prije poništavanja kačenja"</string>
    <string name="lock_to_app_unlock_password" msgid="9126722403506560473">"Traži lozinku prije nego se otkači"</string>
    <string name="package_installed_device_owner" msgid="7035926868974878525">"Instalirao je vaš administrator"</string>
    <string name="package_updated_device_owner" msgid="7560272363805506941">"Ažurirao je vaš administrator"</string>
    <string name="package_deleted_device_owner" msgid="2292335928930293023">"Izbrisao je vaš administrator"</string>
    <string name="confirm_battery_saver" msgid="5247976246208245754">"Uredu"</string>
    <string name="battery_saver_description_with_learn_more" msgid="5444908404021316250">"Ušteda baterije uključuje tamnu temu i ograničava ili isključuje aktivnost u pozadini, određene vizuelne efekte i funkcije te neke mrežne veze."</string>
    <string name="battery_saver_description" msgid="8518809702138617167">"Ušteda baterije uključuje tamnu temu i ograničava ili isključuje aktivnost u pozadini, određene vizuelne efekte i funkcije te neke mrežne veze."</string>
    <string name="data_saver_description" msgid="4995164271550590517">"Radi smanjenja prijenosa 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. Naprimjer, to može značiti da se slike ne prikazuju dok ih ne dodirnete."</string>
    <string name="data_saver_enable_title" msgid="7080620065745260137">"Uključiti Uštedu podataka?"</string>
    <string name="data_saver_enable_button" msgid="4399405762586419726">"Uključi"</string>
    <string name="zen_mode_duration_minutes_summary" msgid="4555514757230849789">"{count,plural, =1{Traje jednu minutu (do {formattedTime})}one{Traje # min (do {formattedTime})}few{Traje # min (do {formattedTime})}other{Traje # min (do {formattedTime})}}"</string>
    <string name="zen_mode_duration_minutes_summary_short" msgid="1187553788355486950">"{count,plural, =1{Traje 1 min (do {formattedTime})}one{Traje # min (do {formattedTime})}few{Traje # min (do {formattedTime})}other{Traje # min (do {formattedTime})}}"</string>
    <string name="zen_mode_duration_hours_summary" msgid="3866333100793277211">"{count,plural, =1{Traje 1 h (do {formattedTime})}one{Traje # h (do {formattedTime})}few{Traje # h (do {formattedTime})}other{Traje # h (do {formattedTime})}}"</string>
    <string name="zen_mode_duration_hours_summary_short" msgid="687919813833347945">"{count,plural, =1{Traje 1 h (do {formattedTime})}one{Traje # h (do {formattedTime})}few{Traje # h (do {formattedTime})}other{Traje # h (do {formattedTime})}}"</string>
    <string name="zen_mode_duration_minutes" msgid="2340007982276569054">"{count,plural, =1{Traje jednu minutu}one{Traje # min}few{Traje # min}other{Traje # min}}"</string>
    <string name="zen_mode_duration_minutes_short" msgid="2435756450204526554">"{count,plural, =1{Traje 1 min}one{Traje # min}few{Traje # min}other{Traje # min}}"</string>
    <string name="zen_mode_duration_hours" msgid="7841806065034711849">"{count,plural, =1{Traje 1 h}one{Traje # h}few{Traje # h}other{Traje # h}}"</string>
    <string name="zen_mode_duration_hours_short" msgid="3666949653933099065">"{count,plural, =1{Traje 1 h}one{Traje # h}few{Traje # h}other{Traje # h}}"</string>
    <string name="zen_mode_until_next_day" msgid="1403042784161725038">"Do: <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_until" msgid="2250286190237669079">"Do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_alarm" msgid="7046911727540499275">"Do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g> (sljedeći alarm)"</string>
    <string name="zen_mode_forever" msgid="740585666364912448">"Dok ne isključite"</string>
    <string name="zen_mode_forever_dnd" msgid="3423201955704180067">"Dok ne isključite način rada Ne ometaj"</string>
    <string name="zen_mode_rule_name_combination" msgid="7174598364351313725">"<xliff:g id="FIRST">%1$s</xliff:g>/<xliff:g id="REST">%2$s</xliff:g>"</string>
    <string name="toolbar_collapse_description" msgid="8009920446193610996">"Suzi"</string>
    <string name="zen_mode_feature_name" msgid="3785547207263754500">"Ne ometaj"</string>
    <string name="zen_mode_downtime_feature_name" msgid="5886005761431427128">"Neaktivnost"</string>
    <string name="zen_mode_default_weeknights_name" msgid="7902108149994062847">"Radni dan uvečer"</string>
    <string name="zen_mode_default_weekends_name" msgid="4707200272709377930">"Vikend"</string>
    <string name="zen_mode_default_events_name" msgid="2280682960128512257">"Događaj"</string>
    <string name="zen_mode_default_every_night_name" msgid="1467765312174275823">"Spavanje"</string>
    <string name="muted_by" msgid="91464083490094950">"<xliff:g id="THIRD_PARTY">%1$s</xliff:g> isključuje neke zvukove"</string>
    <string name="system_error_wipe_data" msgid="5910572292172208493">"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="703545241070116315">"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="3139884150741157610">"USSD zahtjev je promijenjen u obični poziv"</string>
    <string name="stk_cc_ussd_to_ss" msgid="4826846653052609738">"USSD zahtjev je promijenjen u SS zahtjev"</string>
    <string name="stk_cc_ussd_to_ussd" msgid="8343001461299302472">"Promijenjeno u novi USSD zahtjev"</string>
    <string name="stk_cc_ussd_to_dial_video" msgid="429118590323618623">"USSD zahtjev je promijenjen u video poziv"</string>
    <string name="stk_cc_ss_to_dial" msgid="4087396658768717077">"SS zahtjev je promijenjen u obični poziv"</string>
    <string name="stk_cc_ss_to_dial_video" msgid="1324194624384312664">"SS zahtjev je promijenjen u video poziv"</string>
    <string name="stk_cc_ss_to_ussd" msgid="8417905193112944760">"SS zahtjev je promijenjen u USSD zahtjev"</string>
    <string name="stk_cc_ss_to_ss" msgid="132040645206514450">"Promijenjeno u novi SS zahtjev"</string>
    <string name="notification_phishing_alert_content_description" msgid="494227305355958790">"Upozorenje o krađi identiteta"</string>
    <string name="notification_work_profile_content_description" msgid="5296477955677725799">"Profil za posao"</string>
    <string name="notification_alerted_content_description" msgid="6139691253611265992">"Upozoreni"</string>
    <string name="notification_verified_content_description" msgid="6401483602782359391">"Potvrđeno"</string>
    <string name="expand_button_content_description_collapsed" msgid="3873368935659010279">"Proširi"</string>
    <string name="expand_button_content_description_expanded" msgid="7484217944948667489">"Suzi"</string>
    <string name="expand_action_accessibility" msgid="1947657036871746627">"aktiviraj/deaktiviraj proširenje"</string>
    <string name="usb_midi_peripheral_name" msgid="490523464968655741">"Android USB ulaz za periferijske uređaje"</string>
    <string name="usb_midi_peripheral_manufacturer_name" msgid="7557148557088787741">"Android"</string>
    <string name="usb_midi_peripheral_product_name" msgid="2836276258480904434">"USB ulaz za periferijske uređaje"</string>
    <string name="floating_toolbar_open_overflow_description" msgid="2260297653578167367">"Još opcija"</string>
    <string name="floating_toolbar_close_overflow_description" msgid="3949818077708138098">"Zatvori preklopni meni"</string>
    <string name="maximize_button_text" msgid="4258922519914732645">"Povećaj maksimalno"</string>
    <string name="close_button_text" msgid="10603510034455258">"Zatvori"</string>
    <string name="notification_messaging_title_template" msgid="772857526770251989">"<xliff:g id="CONVERSATION_TITLE">%1$s</xliff:g>: <xliff:g id="SENDER_NAME">%2$s</xliff:g>"</string>
    <string name="call_notification_answer_action" msgid="5999246836247132937">"Odgovori"</string>
    <string name="call_notification_answer_video_action" msgid="2086030940195382249">"Video"</string>
    <string name="call_notification_decline_action" msgid="3700345945214000726">"Odbaci"</string>
    <string name="call_notification_hang_up_action" msgid="9130720590159188131">"Prekini vezu"</string>
    <string name="call_notification_incoming_text" msgid="6143109825406638201">"Dolazni poziv"</string>
    <string name="call_notification_ongoing_text" msgid="3880832933933020875">"Poziv u toku"</string>
    <string name="call_notification_screening_text" msgid="8396931408268940208">"Filtriranje dolaznog poziva"</string>
    <string name="default_notification_channel_label" msgid="3697928973567217330">"Nije kategorizirano"</string>
    <string name="importance_from_user" msgid="2782756722448800447">"Vi određujete značaj ovih obavještenja."</string>
    <string name="importance_from_person" msgid="4235804979664465383">"Ovo je značajno zbog osoba koje su uključene."</string>
    <string name="notification_history_title_placeholder" msgid="7748630986182249599">"Prilagođeno obavještenje aplikacije"</string>
    <string name="user_creation_account_exists" msgid="2239146360099708035">"Dozvoliti aplikaciji <xliff:g id="APP">%1$s</xliff:g> da kreira novog korisnika s računom <xliff:g id="ACCOUNT">%2$s</xliff:g> (korisnik s ovim računom već postoji)?"</string>
    <string name="user_creation_adding" msgid="7305185499667958364">"Dozvoliti 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="supervised_user_creation_label" msgid="6884904353827427515">"Dodaj korisnika pod nadzorom"</string>
    <string name="language_selection_title" msgid="52674936078683285">"Dodajte jezik"</string>
    <string name="country_selection_title" msgid="5221495687299014379">"Izbor regije"</string>
    <string name="search_language_hint" msgid="7004225294308793583">"Upišite ime jezika"</string>
    <string name="language_picker_section_suggested" msgid="6556199184638990447">"Predloženo"</string>
    <string name="language_picker_regions_section_suggested" msgid="6080131515268225316">"Predloženo"</string>
    <string name="language_picker_section_all" msgid="1985809075777564284">"Svi jezici"</string>
    <string name="region_picker_section_all" msgid="756441309928774155">"Sve regije"</string>
    <string name="locale_search_menu" msgid="6258090710176422934">"Pretraga"</string>
    <string name="app_suspended_title" msgid="888873445010322650">"Aplikacija nije dostupna"</string>
    <string name="app_suspended_default_message" msgid="6451215678552004172">"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="211260942831587014">"Saznajte više"</string>
    <string name="app_suspended_unsuspend_message" msgid="1665438589450555459">"Ponovo aktiviraj aplikaciju"</string>
    <string name="work_mode_off_title" msgid="961171256005852058">"Uključiti poslovne aplikacije?"</string>
    <string name="work_mode_off_message" msgid="7319580997683623309">"Pristupite poslovnim aplikacijama i obavještenjima"</string>
    <string name="work_mode_turn_on" msgid="3662561662475962285">"Uključi"</string>
    <string name="app_blocked_title" msgid="7353262160455028160">"Aplikacija nije dostupna"</string>
    <string name="app_blocked_message" msgid="542972921087873023">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> trenutno nije dostupna."</string>
    <string name="app_streaming_blocked_title" msgid="6090945835898766139">"Nedostupno: <xliff:g id="ACTIVITY">%1$s</xliff:g>"</string>
    <string name="app_streaming_blocked_title_for_permission_dialog" msgid="4483161748582966785">"Potrebno je odobrenje"</string>
    <string name="app_streaming_blocked_title_for_camera_dialog" msgid="3935701653713853065">"Kamera nije dostupna"</string>
    <string name="app_streaming_blocked_title_for_fingerprint_dialog" msgid="3516853717714141951">"Nastavite na telefonu"</string>
    <string name="app_streaming_blocked_title_for_microphone_dialog" msgid="544822455127171206">"Mikrofon nije dostupan"</string>
    <string name="app_streaming_blocked_title_for_playstore_dialog" msgid="8149823099822897538">"Play trgovina nije dostupna"</string>
    <string name="app_streaming_blocked_title_for_settings_dialog" product="tv" msgid="196994247017450357">"Postavke Android TV-a nisu dostupne"</string>
    <string name="app_streaming_blocked_title_for_settings_dialog" product="tablet" msgid="8222710146267948647">"Postavke tableta nisu dostupne"</string>
    <string name="app_streaming_blocked_title_for_settings_dialog" product="default" msgid="6895719984375299791">"Postavke telefona nisu dostupne"</string>
    <string name="app_streaming_blocked_message" product="tv" msgid="4003011766528814377">"Trenutno ne možete pristupiti ovoj aplikaciji na uređaju <xliff:g id="DEVICE">%1$s</xliff:g>. Umjesto toga pokušajte na uređaju Android TV."</string>
    <string name="app_streaming_blocked_message" product="tablet" msgid="4242053045964946062">"Trenutno ne možete pristupiti ovoj aplikaciji na uređaju <xliff:g id="DEVICE">%1$s</xliff:g>. Umjesto toga pokušajte na tabletu."</string>
    <string name="app_streaming_blocked_message" product="default" msgid="6159168735030739398">"Trenutno ne možete pristupiti ovoj aplikaciji na uređaju <xliff:g id="DEVICE">%1$s</xliff:g>. Umjesto toga pokušajte na telefonu."</string>
    <string name="app_streaming_blocked_message_for_fingerprint_dialog" product="tv" msgid="3470977315395784567">"Ova aplikacija zahtijeva dodatnu sigurnost. Umjesto toga pokušajte na uređaju Android TV."</string>
    <string name="app_streaming_blocked_message_for_fingerprint_dialog" product="tablet" msgid="698460091901465092">"Ova aplikacija zahtijeva dodatnu sigurnost. Umjesto toga pokušajte na tabletu."</string>
    <string name="app_streaming_blocked_message_for_fingerprint_dialog" product="default" msgid="8552691971910603907">"Ova aplikacija zahtijeva dodatnu sigurnost. Umjesto toga pokušajte na telefonu."</string>
    <string name="app_streaming_blocked_message_for_settings_dialog" product="tv" msgid="820334666354451145">"Ne možete pristupiti ovoj aplikaciji na uređaju <xliff:g id="DEVICE">%1$s</xliff:g>. Umjesto toga pokušajte na uređaju Android TV."</string>
    <string name="app_streaming_blocked_message_for_settings_dialog" product="tablet" msgid="3286849551133045896">"Ne možete pristupiti ovoj aplikaciji na uređaju <xliff:g id="DEVICE">%1$s</xliff:g>. Umjesto toga pokušajte na tabletu."</string>
    <string name="app_streaming_blocked_message_for_settings_dialog" product="default" msgid="6264287556598916295">"Ne možete pristupiti ovoj aplikaciji na uređaju <xliff:g id="DEVICE">%1$s</xliff:g>. Umjesto toga pokušajte na telefonu."</string>
    <string name="deprecated_target_sdk_message" msgid="5203207875657579953">"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="8456784048558808909">"Provjeri je li dostupno ažuriranje"</string>
    <string name="new_sms_notification_title" msgid="6528758221319927107">"Imate nove poruke"</string>
    <string name="new_sms_notification_content" msgid="3197949934153460639">"Otvorite SMS aplikaciju da biste pregledali poruke"</string>
    <string name="profile_encrypted_title" msgid="9001208667521266472">"Neke funkcije mogu biti ograničene"</string>
    <string name="profile_encrypted_detail" msgid="5279730442756849055">"Radni profil je zaključan"</string>
    <string name="profile_encrypted_message" msgid="1128512616293157802">"Dodirnite da biste otključali radni profil"</string>
    <string name="usb_mtp_launch_notification_title" msgid="774319638256707227">"Povezan na uređaj <xliff:g id="PRODUCT_NAME">%1$s</xliff:g>"</string>
    <string name="usb_mtp_launch_notification_description" msgid="6942535713629852684">"Dodirnite za prikaz fajlova"</string>
    <string name="pin_target" msgid="8036028973110156895">"Zakači"</string>
    <string name="pin_specific_target" msgid="7824671240625957415">"Zakači aplikaciju <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="unpin_target" msgid="3963318576590204447">"Otkači"</string>
    <string name="unpin_specific_target" msgid="3859828252160908146">"Otkači aplikaciju <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="app_info" msgid="6113278084877079851">"Informacije o aplikaciji"</string>
    <string name="negative_duration" msgid="1938335096972945232">"−<xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="demo_starting_message" msgid="6577581216125805905">"Pokretanje demonstracije…"</string>
    <string name="demo_restarting_message" msgid="1160053183701746766">"Vraćanje uređaja na početne postavke…"</string>
    <string name="suspended_widget_accessibility" msgid="6331451091851326101">"Onemogućen <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="conference_call" msgid="5731633152336490471">"Konferencijski poziv"</string>
    <string name="tooltip_popup_title" msgid="7863719020269945722">"Skočni opis"</string>
    <string name="app_category_game" msgid="4534216074910244790">"Igre"</string>
    <string name="app_category_audio" msgid="8296029904794676222">"Muzika i zvuk"</string>
    <string name="app_category_video" msgid="2590183854839565814">"Filmovi i videozapisi"</string>
    <string name="app_category_image" msgid="7307840291864213007">"Fotografije i slike"</string>
    <string name="app_category_social" msgid="2278269325488344054">"Društvene mreže i komunikacija"</string>
    <string name="app_category_news" msgid="1172762719574964544">"Vijesti i časopisi"</string>
    <string name="app_category_maps" msgid="6395725487922533156">"Mape i navigacija"</string>
    <string name="app_category_productivity" msgid="1844422703029557883">"Produktivnost"</string>
    <string name="app_category_accessibility" msgid="6643521607848547683">"Pristupačnost"</string>
    <string name="device_storage_monitor_notification_channel" msgid="5164244565844470758">"Memorija uređaja"</string>
    <string name="adb_debugging_notification_channel_tv" msgid="4764046459631031496">"Otklanjanje grešaka putem USB-a"</string>
    <string name="time_picker_hour_label" msgid="4208590187662336864">"sat"</string>
    <string name="time_picker_minute_label" msgid="8307452311269824553">"minuta"</string>
    <string name="time_picker_header_text" msgid="9073802285051516688">"Postavljanje vremena"</string>
    <string name="time_picker_input_error" msgid="8386271930742451034">"Unesite ispravno vrijeme"</string>
    <string name="time_picker_prompt_label" msgid="303588544656363889">"Upišite vrijeme"</string>
    <string name="time_picker_text_input_mode_description" msgid="4761160667516611576">"Prebacite u način unosa teksta za unos vremena."</string>
    <string name="time_picker_radial_mode_description" msgid="1222342577115016953">"Prebacite u način rada kao sat za unos vremena."</string>
    <string name="autofill_picker_accessibility_title" msgid="4425806874792196599">"Opcije za automatsko popunjavanje"</string>
    <string name="autofill_save_accessibility_title" msgid="1523225776218450005">"Sačuvaj za automatsko popunjavanje"</string>
    <string name="autofill_error_cannot_autofill" msgid="6528827648643138596">"Sadržaje nije moguće automatski popuniti"</string>
    <string name="autofill_picker_no_suggestions" msgid="1076022650427481509">"Nema prijedloga za automatsko popunjavanje"</string>
    <string name="autofill_picker_some_suggestions" msgid="5560549696296202701">"{count,plural, =1{Jedan prijedlog za automatsko popunjavanje}one{# prijedlog za automatsko popunjavanje}few{# prijedloga za automatsko popunjavanje}other{# prijedloga za automatsko popunjavanje}}"</string>
    <string name="autofill_save_title" msgid="7719802414283739775">"Sačuvati u "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>"?"</string>
    <string name="autofill_save_title_with_type" msgid="3002460014579799605">"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="3783270967447869241">"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="6598228952100102578">"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="3630695947047069136">"Ažurirati u "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>"?"</string>
    <string name="autofill_update_title_with_type" msgid="5264152633488495704">"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="1797514386321086273">"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="1312232153076212291">"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="8035743017382012850">"Sačuvaj"</string>
    <string name="autofill_save_no" msgid="9212826374207023544">"Ne, hvala"</string>
    <string name="autofill_save_notnow" msgid="2853932672029024195">"Ne sada"</string>
    <string name="autofill_save_never" msgid="6821841919831402526">"Nikada"</string>
    <string name="autofill_update_yes" msgid="4608662968996874445">"Ažuriraj"</string>
    <string name="autofill_continue_yes" msgid="7914985605534510385">"Nastavi"</string>
    <string name="autofill_save_type_password" msgid="5624528786144539944">"lozinka"</string>
    <string name="autofill_save_type_address" msgid="3111006395818252885">"adresa"</string>
    <string name="autofill_save_type_credit_card" msgid="3583795235862046693">"kreditna kartica"</string>
    <string name="autofill_save_type_debit_card" msgid="3169397504133097468">"debitna kartica"</string>
    <string name="autofill_save_type_payment_card" msgid="6555012156728690856">"kartica za plaćanje"</string>
    <string name="autofill_save_type_generic_card" msgid="1019367283921448608">"kartica"</string>
    <string name="autofill_save_type_username" msgid="1018816929884640882">"korisničko ime"</string>
    <string name="autofill_save_type_email_address" msgid="1303262336895591924">"adresa e-pošte"</string>
    <string name="etws_primary_default_message_earthquake" msgid="8401079517718280669">"Ostanite smireni i potražite sklonište u blizini."</string>
    <string name="etws_primary_default_message_tsunami" msgid="5828171463387976279">"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="4888224011071875068">"Ostanite smireni i potražite sklonište u blizini."</string>
    <string name="etws_primary_default_message_test" msgid="4583367373909549421">"Test poruka za hitne slučajeve"</string>
    <string name="notification_reply_button_accessibility" msgid="5235776156579456126">"Odgovori"</string>
    <string name="etws_primary_default_message_others" msgid="7958161706019130739"></string>
    <string name="mmcc_authentication_reject" msgid="4891965994643876369">"SIM kartica nije dozvoljena za govor"</string>
    <string name="mmcc_imsi_unknown_in_hlr" msgid="227760698553988751">"SIM kartica nije dodijeljena za govor"</string>
    <string name="mmcc_illegal_ms" msgid="7509650265233909445">"SIM kartica nije dozvoljena za govor"</string>
    <string name="mmcc_illegal_me" msgid="6505557881889904915">"Telefon nije dozvoljen za govor"</string>
    <string name="mmcc_authentication_reject_msim_template" msgid="4480853038909922153">"SIM <xliff:g id="SIMNUMBER">%d</xliff:g> nije dozvoljen"</string>
    <string name="mmcc_imsi_unknown_in_hlr_msim_template" msgid="3688508325248599657">"SIM <xliff:g id="SIMNUMBER">%d</xliff:g> nije dodijeljen"</string>
    <string name="mmcc_illegal_ms_msim_template" msgid="832644375774599327">"SIM <xliff:g id="SIMNUMBER">%d</xliff:g> nije dozvoljen"</string>
    <string name="mmcc_illegal_me_msim_template" msgid="4802735138861422802">"SIM <xliff:g id="SIMNUMBER">%d</xliff:g> nije dozvoljen"</string>
    <string name="popup_window_default_title" msgid="6907717596694826919">"Iskočni prozor"</string>
    <string name="slice_more_content" msgid="3377367737876888459">"+ <xliff:g id="NUMBER">%1$d</xliff:g>"</string>
    <string name="shortcut_restored_on_lower_version" msgid="9206301954024286063">"Instalirana je starija verzija aplikacije ili aplikacija nije kompatibilna s ovom prečicom"</string>
    <string name="shortcut_restore_not_supported" msgid="4763198938588468400">"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="579345304221605479">"Prečica nije uspješno vraćena zbog nepodudaranja potpisa aplikacije"</string>
    <string name="shortcut_restore_unknown_issue" msgid="2478146134395982154">"Prečica nije uspješno vraćena"</string>
    <string name="shortcut_disabled_reason_unknown" msgid="753074793553599166">"Prečica je onemogućena"</string>
    <string name="harmful_app_warning_uninstall" msgid="6472912975664191772">"DEINSTALIRAJ"</string>
    <string name="harmful_app_warning_open_anyway" msgid="5963657791740211807">"IPAK OTVORI"</string>
    <string name="harmful_app_warning_title" msgid="8794823880881113856">"Otkrivena je štetna aplikacija"</string>
    <string name="log_access_confirmation_title" msgid="2343578467290592708">"Dozvoliti aplikaciji <xliff:g id="LOG_ACCESS_APP_NAME">%s</xliff:g> da pristupa svim zapisnicima uređaja?"</string>
    <string name="log_access_confirmation_allow" msgid="5302517782599389507">"Dozvoli jednokratan pristup"</string>
    <string name="log_access_confirmation_deny" msgid="7685790957455099845">"Nemoj dozvoliti"</string>
    <string name="log_access_confirmation_body" msgid="1806692062668620735">"Zapisnici uređaja bilježe šta se dešava na uređaju. Aplikacije mogu koristiti te zapisnike da pronađu i isprave probleme.\n\nNeki zapisnici mogu sadržavati osjetljive podatke, zato pristup svim zapisnicima uređaja dozvolite samo aplikacijama kojima vjerujete. \n\nAko ne dozvolite ovoj aplikaciji da pristupa svim zapisnicima uređaja, ona i dalje može pristupati svojim zapisnicima. Proizvođač uređaja će možda i dalje biti u stanju pristupiti nekim zapisnicima ili podacima na uređaju."</string>
    <string name="log_access_do_not_show_again" msgid="1058690599083091552">"Ne prikazuj ponovo"</string>
    <string name="slices_permission_request" msgid="3677129866636153406">"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="7408934887203689207">"Uredi"</string>
    <string name="volume_dialog_ringer_guidance_vibrate" msgid="2055927873175228519">"Pozivi i obavještenja će vibrirati"</string>
    <string name="volume_dialog_ringer_guidance_silent" msgid="1011246774949993783">"Pozivi i obavještenja će se isključiti"</string>
    <string name="notification_channel_system_changes" msgid="2462010596920209678">"Sistemske promjene"</string>
    <string name="notification_channel_do_not_disturb" msgid="7832584281883687653">"Ne ometaj"</string>
    <string name="zen_upgrade_notification_visd_title" msgid="2001148984371968620">"Novo: Način rada Ne ometaj sakriva obavještenja"</string>
    <string name="zen_upgrade_notification_visd_content" msgid="3683314609114134946">"Dodirnite da saznate više i izvršite promjene."</string>
    <string name="zen_upgrade_notification_title" msgid="8198167698095298717">"Način rada Ne ometaj je promijenjen"</string>
    <string name="zen_upgrade_notification_content" msgid="5228458567180124005">"Dodirnite da provjerite šta je blokirano."</string>
    <string name="review_notification_settings_title" msgid="5102557424459810820">"Pregledajte postavke obavještenja"</string>
    <string name="review_notification_settings_text" msgid="5916244866751849279">"Počevši od Androida 13, aplikacije koje instalirate trebaju odobrenje da šalju obavještenja. Dodirnite da promijenite ovo odobrenje za postojeće aplikacije."</string>
    <string name="review_notification_settings_remind_me_action" msgid="1081081018678480907">"Podsjeti me kasnije"</string>
    <string name="review_notification_settings_dismiss" msgid="4160916504616428294">"Odbaci"</string>
    <string name="notification_app_name_system" msgid="3045196791746735601">"Sistem"</string>
    <string name="notification_app_name_settings" msgid="9088548800899952531">"Postavke"</string>
    <string name="notification_appops_camera_active" msgid="8177643089272352083">"Kamera"</string>
    <string name="notification_appops_microphone_active" msgid="581333393214739332">"Mikrofon"</string>
    <string name="notification_appops_overlay_active" msgid="5571732753262836481">"prikazivanje preko drugih aplikacija na ekranu"</string>
    <string name="notification_feedback_indicator" msgid="663476517711323016">"Pružanje povratnih informacija"</string>
    <string name="notification_feedback_indicator_alerted" msgid="6552871804121942099">"Značaj ovog obavještenja je povećan na Zadano. Dodirnite da pošaljete povratne informacije."</string>
    <string name="notification_feedback_indicator_silenced" msgid="3799442124723177262">"Značaj ovog obavještenja je umanjen na Nečujno. Dodirnite da pošaljete povratne informacije."</string>
    <string name="notification_feedback_indicator_promoted" msgid="9030204303764698640">"Značaj ovog obavještenja je povećan. Dodirnite da pošaljete povratne informacije."</string>
    <string name="notification_feedback_indicator_demoted" msgid="8880309924296450875">"Značaj ovog obavještenja je umanjen. Dodirnite da pošaljete povratne informacije."</string>
    <string name="nas_upgrade_notification_title" msgid="8436359459300146555">"Poboljšana obavještenja"</string>
    <string name="nas_upgrade_notification_content" msgid="5157550369837103337">"Poboljšana obavještenja sada pružaju predložene radnje i odgovore. Prilagodljiva obavještenja Androida više nisu podržana."</string>
    <string name="nas_upgrade_notification_enable_action" msgid="3046406808378726874">"Uredu"</string>
    <string name="nas_upgrade_notification_disable_action" msgid="3794833210043497982">"Isključi"</string>
    <string name="nas_upgrade_notification_learn_more_action" msgid="7011130656195423947">"Saznajte više"</string>
    <string name="nas_upgrade_notification_learn_more_content" msgid="3735480566983530650">"Poboljšana obavještenja su zamijenila Prilagodljiva obavještenja Androida u verziji Android 12. Ova funkcija prikazuje predložene radnje i odgovore te organizira vaša obavještenja.\n\nPoboljšana obavještenja mogu pristupiti sadržaju obavještenja, uključujući lične informacije kao što su imena kontakata i poruke. Ova funkcija također može odbacivati obavještenja ili reagirati na njih, npr. može odgovarati na telefonske pozive i kontrolirati funkciju Ne ometaj."</string>
    <string name="dynamic_mode_notification_channel_name" msgid="2986926422100223328">"Obavještenje za informacije Rutinskog načina"</string>
    <string name="dynamic_mode_notification_title" msgid="9205715501274608016">"Moguće je da će se baterija isprazniti prije uobičajenog punjenja"</string>
    <string name="dynamic_mode_notification_summary" msgid="4141614604437372157">"Ušteda baterije je aktivirana da bi se produžio vijek trajanja baterije"</string>
    <string name="battery_saver_notification_channel_name" msgid="3918243458067916913">"Ušteda baterije"</string>
    <string name="battery_saver_off_notification_title" msgid="7637255960468032515">"Ušteda baterije je isključena"</string>
    <string name="battery_saver_charged_notification_summary" product="default" msgid="5544457317418624367">"Telefon se dovoljno napunio. Funkcije nisu više ograničene."</string>
    <string name="battery_saver_charged_notification_summary" product="tablet" msgid="4426317048139996888">"Tablet se dovoljno napunio. Funkcije nisu više ograničene."</string>
    <string name="battery_saver_charged_notification_summary" product="device" msgid="1031562417867646649">"Uređaj se dovoljno napunio. Funkcije nisu više ograničene."</string>
    <string name="mime_type_folder" msgid="2203536499348787650">"Folder"</string>
    <string name="mime_type_apk" msgid="3168784749499623902">"Android aplikacija"</string>
    <string name="mime_type_generic" msgid="4606589110116560228">"Fajl"</string>
    <string name="mime_type_generic_ext" msgid="9220220924380909486">"<xliff:g id="EXTENSION">%1$s</xliff:g> fajl"</string>
    <string name="mime_type_audio" msgid="4933450584432509875">"Zvučni zapis"</string>
    <string name="mime_type_audio_ext" msgid="2615491023840514797">"<xliff:g id="EXTENSION">%1$s</xliff:g> zvučni zapis"</string>
    <string name="mime_type_video" msgid="7071965726609428150">"Videozapis"</string>
    <string name="mime_type_video_ext" msgid="185438149044230136">"<xliff:g id="EXTENSION">%1$s</xliff:g> videozapis"</string>
    <string name="mime_type_image" msgid="2134307276151645257">"Slika"</string>
    <string name="mime_type_image_ext" msgid="5743552697560999471">"<xliff:g id="EXTENSION">%1$s</xliff:g> slika"</string>
    <string name="mime_type_compressed" msgid="8737300936080662063">"Arhiva"</string>
    <string name="mime_type_compressed_ext" msgid="4775627287994475737">"<xliff:g id="EXTENSION">%1$s</xliff:g> arhiva"</string>
    <string name="mime_type_document" msgid="3737256839487088554">"Dokument"</string>
    <string name="mime_type_document_ext" msgid="2398002765046677311">"<xliff:g id="EXTENSION">%1$s</xliff:g> dokument"</string>
    <string name="mime_type_spreadsheet" msgid="8188407519131275838">"Tabela"</string>
    <string name="mime_type_spreadsheet_ext" msgid="8720173181137254414">"<xliff:g id="EXTENSION">%1$s</xliff:g> tabela"</string>
    <string name="mime_type_presentation" msgid="1145384236788242075">"Prezentacija"</string>
    <string name="mime_type_presentation_ext" msgid="8761049335564371468">"<xliff:g id="EXTENSION">%1$s</xliff:g> prezentacija"</string>
    <string name="bluetooth_airplane_mode_toast" msgid="2066399056595768554">"Bluetooth će ostati uključen tokom načina rada u avionu"</string>
    <string name="car_loading_profile" msgid="8219978381196748070">"Učitavanje"</string>
    <string name="file_count" msgid="3220018595056126969">"{count,plural, =1{{file_name} i # fajl}one{{file_name} i # fajl}few{{file_name} i # fajla}other{{file_name} i # fajlova}}"</string>
    <string name="chooser_no_direct_share_targets" msgid="1511722103987329028">"Nema preporučenih osoba s kojima biste dijelili"</string>
    <string name="chooser_all_apps_button_label" msgid="3230427756238666328">"Lista aplikacija"</string>
    <string name="usb_device_resolve_prompt_warn" msgid="325871329788064199">"Ovoj aplikaciji nije dato odobrenje za snimanje, ali može snimati zvuk putem ovog USB uređaja."</string>
    <string name="accessibility_system_action_home_label" msgid="3234748160850301870">"Početna stranica"</string>
    <string name="accessibility_system_action_back_label" msgid="4205361367345537608">"Nazad"</string>
    <string name="accessibility_system_action_recents_label" msgid="4782875610281649728">"Nedavne aplikacije"</string>
    <string name="accessibility_system_action_notifications_label" msgid="6083767351772162010">"Obavještenja"</string>
    <string name="accessibility_system_action_quick_settings_label" msgid="4583900123506773783">"Brze postavke"</string>
    <string name="accessibility_system_action_power_dialog_label" msgid="8095341821683910781">"Dijaloški okvir za napajanje"</string>
    <string name="accessibility_system_action_lock_screen_label" msgid="5484190691945563838">"Zaključavanje ekrana"</string>
    <string name="accessibility_system_action_screenshot_label" msgid="3581566515062741676">"Snimak ekrana"</string>
    <string name="accessibility_system_action_headset_hook_label" msgid="8524691721287425468">"Kuka za slušalice"</string>
    <string name="accessibility_system_action_on_screen_a11y_shortcut_label" msgid="8488701469459210309">"Prečica za pristupačnost na ekranu"</string>
    <string name="accessibility_system_action_on_screen_a11y_shortcut_chooser_label" msgid="1057878690209817886">"Okvir za odabir prečice za pristupačnost na ekranu"</string>
    <string name="accessibility_system_action_hardware_a11y_shortcut_label" msgid="5764644187715255107">"Prečica za pristupačnost"</string>
    <string name="accessibility_system_action_dismiss_notification_shade" msgid="8931637495533770352">"Odbacite lokaciju za obavještenja"</string>
    <string name="accessibility_system_action_dpad_up_label" msgid="1029042950229333782">"Upravljač gore"</string>
    <string name="accessibility_system_action_dpad_down_label" msgid="3441918448624921461">"Upravljač dolje"</string>
    <string name="accessibility_system_action_dpad_left_label" msgid="6557647179116479152">"Upravljač lijevo"</string>
    <string name="accessibility_system_action_dpad_right_label" msgid="9180196950365804081">"Upravljač desno"</string>
    <string name="accessibility_system_action_dpad_center_label" msgid="8149791419358224893">"Upravljač sredina"</string>
    <string name="accessibility_freeform_caption" msgid="8377519323496290122">"Traka za natpis aplikacije <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="as_app_forced_to_restricted_bucket" msgid="8233871289353898964">"Paket <xliff:g id="PACKAGE_NAME">%1$s</xliff:g> je stavljen u odjeljak OGRANIČENO"</string>
    <string name="conversation_single_line_name_display" msgid="8958948312915255999">"<xliff:g id="SENDER_NAME">%1$s</xliff:g>:"</string>
    <string name="conversation_single_line_image_placeholder" msgid="6983271082911936900">"je poslao/la sliku"</string>
    <string name="conversation_title_fallback_one_to_one" msgid="1980753619726908614">"Razgovor"</string>
    <string name="conversation_title_fallback_group_chat" msgid="456073374993104303">"Grupni razgovor"</string>
    <string name="unread_convo_overflow" msgid="920517615597353833">"<xliff:g id="MAX_UNREAD_COUNT">%1$d</xliff:g>+"</string>
    <string name="resolver_personal_tab" msgid="2051260504014442073">"Lično"</string>
    <string name="resolver_work_tab" msgid="2690019516263167035">"Posao"</string>
    <string name="resolver_personal_tab_accessibility" msgid="5739524949153091224">"Prikaz ličnog sadržaja"</string>
    <string name="resolver_work_tab_accessibility" msgid="4753168230363802734">"Prikaz poslovnog sadržaja"</string>
    <string name="resolver_cross_profile_blocked" msgid="3014597376026044840">"Blokirao je vaš IT administrator"</string>
    <string name="resolver_cant_share_with_work_apps_explanation" msgid="9071442683080586643">"Ovaj sadržaj nije moguće dijeliti pomoću poslovnih aplikacija"</string>
    <string name="resolver_cant_access_work_apps_explanation" msgid="1129960195389373279">"Ovaj sadržaj nije moguće otvoriti pomoću poslovnih aplikacija"</string>
    <string name="resolver_cant_share_with_personal_apps_explanation" msgid="6349766201904601544">"Ovaj sadržaj nije moguće dijeliti pomoću ličnih aplikacija"</string>
    <string name="resolver_cant_access_personal_apps_explanation" msgid="1679399548862724359">"Ovaj sadržaj nije moguće otvoriti pomoću ličnih aplikacija"</string>
    <string name="resolver_turn_on_work_apps" msgid="884910835250037247">"Radni profil je pauziran"</string>
    <string name="resolver_switch_on_work" msgid="463709043650610420">"Dodirnite da uključite"</string>
    <string name="resolver_no_work_apps_available" msgid="3298291360133337270">"Nema poslovnih aplikacija"</string>
    <string name="resolver_no_personal_apps_available" msgid="6284837227019594881">"Nema ličnih aplikacija"</string>
    <string name="miniresolver_open_in_personal" msgid="3874522693661065566">"Otvoriti aplikaciju <xliff:g id="APP">%s</xliff:g> na ličnom profilu?"</string>
    <string name="miniresolver_open_in_work" msgid="4415223793669536559">"Otvoriti aplikaciju <xliff:g id="APP">%s</xliff:g> na radnom profilu?"</string>
    <string name="miniresolver_use_personal_browser" msgid="776072682871133308">"Koristi lični preglednik"</string>
    <string name="miniresolver_use_work_browser" msgid="543575306251952994">"Koristi poslovni preglednik"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_ENTRY" msgid="8050953231914637819">"PIN za otključavanje mreže na SIM-u"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_ENTRY" msgid="7164399703751688214">"PIN za otključavanje mrežne podgrupe na SIM-u"</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_ENTRY" msgid="4447629474818217364">"PIN za otključavanje korporativnog SIM-a"</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_ENTRY" msgid="973059024670737358">"PIN za otključavanje SIM-a pružaoca usluge"</string>
    <string name="PERSOSUBSTATE_SIM_SIM_ENTRY" msgid="4487435301206073787">"PIN za otključavanje SIM-a"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_PUK_ENTRY" msgid="768060297218652809">"Unesite PUK"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK_ENTRY" msgid="7129527319490548930">"Unesite PUK"</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_PUK_ENTRY" msgid="2876126640607573252">"Unesite PUK"</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK_ENTRY" msgid="8952595089930109282">"Unesite PUK"</string>
    <string name="PERSOSUBSTATE_SIM_SIM_PUK_ENTRY" msgid="3013902515773728996">"Unesite PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_ENTRY" msgid="2974411408893410289">"PIN za otključavanje mreže 1 na RUIM-u"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_ENTRY" msgid="687618528751880721">"PIN za otključavanje mreže 2 na RUIM-u"</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_ENTRY" msgid="6810596579655575381">"PIN za otključavanje RUIM hrpd-a"</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_ENTRY" msgid="2715929642540980259">"PIN za otključavanje korporativnog RUIM-a"</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_ENTRY" msgid="8557791623303951590">"PIN za otključavanje RUIM-a pružaoca usluge"</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_ENTRY" msgid="7382468767274580323">"PIN za otključavanje RUIM-a"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_PUK_ENTRY" msgid="6730880791104286987">"Unesite PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_PUK_ENTRY" msgid="6432126539782267026">"Unesite PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_PUK_ENTRY" msgid="1730510161529488920">"Unesite PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK_ENTRY" msgid="3369885925003346830">"Unesite PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_PUK_ENTRY" msgid="9129139686191167829">"Unesite PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_PUK_ENTRY" msgid="2869929685874615358">"Unesite PUK"</string>
    <string name="PERSOSUBSTATE_SIM_SPN_ENTRY" msgid="1238663472392741771">"PIN za otključavanje SPN-a"</string>
    <string name="PERSOSUBSTATE_SIM_SP_EHPLMN_ENTRY" msgid="3988705848553894358">"PIN za otključavanje ekvivalentnog kućnog PLMN-a pružaoca usluge"</string>
    <string name="PERSOSUBSTATE_SIM_ICCID_ENTRY" msgid="6186770686690993200">"PIN za otključavanje ICCID-a"</string>
    <string name="PERSOSUBSTATE_SIM_IMPI_ENTRY" msgid="7043865376145617024">"PIN za otključavanje IMPI-ja"</string>
    <string name="PERSOSUBSTATE_SIM_NS_SP_ENTRY" msgid="6144227308185112176">"PIN za otključavanje mrežne podgrupe pružaoca usluge"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_IN_PROGRESS" msgid="4233355366318061180">"Zahtijevanje otključavanja mreže na SIM-u…"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_IN_PROGRESS" msgid="6742563947637715645">"Zahtijevanje otključavanja mrežne podgrupe na SIM-u…"</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_IN_PROGRESS" msgid="2033399698172403560">"Zahtijevanje otključavanja SIM-a pružaoca usluge…"</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_IN_PROGRESS" msgid="4795977251920732254">"Zahtijevanje otključavanja korporativnog SIM-a…"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_PUK_IN_PROGRESS" msgid="1090425878157254446">"Zahtijevanje otključavanja PUK-om…"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK_IN_PROGRESS" msgid="6476898876518094438">"Zahtijevanje otključavanja PUK-om…"</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_PUK_IN_PROGRESS" msgid="6006806734293747731">"Zahtijevanje otključavanja PUK-om…"</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK_IN_PROGRESS" msgid="6546680489620881893">"Zahtijevanje otključavanja PUK-om…"</string>
    <string name="PERSOSUBSTATE_SIM_SIM_PUK_IN_PROGRESS" msgid="3506845511000727015">"Zahtijevanje otključavanja PUK-om…"</string>
    <string name="PERSOSUBSTATE_SIM_SIM_IN_PROGRESS" msgid="6709169861932992750">"Zahtijevanje otključavanja SIM-a…"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_IN_PROGRESS" msgid="4013870911606478520">"Zahtijevanje otključivanja mreže 1 na RUIM-u…"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_IN_PROGRESS" msgid="9032651188219523434">"Zahtijevanje otključavanja mreže 1 na RUIM-u…"</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_IN_PROGRESS" msgid="6584576506344491207">"Zahtijevanje otključavanje RUIM hrpd-a…"</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_IN_PROGRESS" msgid="830981927724888114">"Zahtijevanje otključavanja RUIM-a pružaoca usluge…"</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_IN_PROGRESS" msgid="7851790973098894802">"Zahtijevanje otključavanja korporativnog RUIM-a…"</string>
    <string name="PERSOSUBSTATE_SIM_SPN_IN_PROGRESS" msgid="1149560739586960121">"Zahtijevanje otključavanja SPN-a…"</string>
    <string name="PERSOSUBSTATE_SIM_SP_EHPLMN_IN_PROGRESS" msgid="5708964693522116025">"Zahtijevanje otključavanja ekvivalentnog kućnog PLMN-a pružaoca usluge…"</string>
    <string name="PERSOSUBSTATE_SIM_ICCID_IN_PROGRESS" msgid="7288103122966483455">"Zahtijevanje otključavanja ICCID-a…"</string>
    <string name="PERSOSUBSTATE_SIM_IMPI_IN_PROGRESS" msgid="4036752174056147753">"Zahtijevanje otključavanja IMPI-ja…"</string>
    <string name="PERSOSUBSTATE_SIM_NS_SP_IN_PROGRESS" msgid="5089536274515338566">"Zahtijevanje otključavanja mrežne podgrupe pružaoca usluge…"</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_IN_PROGRESS" msgid="6737197986936251958">"Zahtijevanje otključavanja RUIM-a…"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_PUK_IN_PROGRESS" msgid="5658767775619998623">"Zahtijevanje otključavanja PUK-om…"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_PUK_IN_PROGRESS" msgid="665978313257653727">"Zahtijevanje otključavanja PUK-om…"</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_PUK_IN_PROGRESS" msgid="3857142652251836850">"Zahtijevanje otključavanja PUK-om…"</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_PUK_IN_PROGRESS" msgid="2695664012344346788">"Zahtijevanje otključavanja PUK-om…"</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK_IN_PROGRESS" msgid="2695678959963807782">"Zahtijevanje otključavanja PUK-om…"</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_PUK_IN_PROGRESS" msgid="1230605365926493599">"Zahtijevanje otključavanja PUK-om…"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_ERROR" msgid="1924844017037151535">"Zahtjev za otključavanje mreže na SIM-u je neuspješan."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_ERROR" msgid="3372797822292089708">"Zahtjev za otključavanje mrežne podgrupe na SIM-u je neuspješan."</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_ERROR" msgid="1878443146720411381">"Zahtjev za otključavanje SIM-a pružaoca usluge je neuspješan."</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_ERROR" msgid="7664778312218023192">"Zahtjev za otključavanje korporativnog SIM-a je neuspješan."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_ERROR" msgid="2472944311643350302">"Zahtjev za otključavanje SIM-a je neuspješan."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_ERROR" msgid="828089694480999120">"Zahtjev za otključavanje mreže 1 na RUIM-u je neuspješan."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_ERROR" msgid="17619001007092511">"Zahtjev za otkjučavanje mreže 2 na RUIM-u je neuspješan."</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_ERROR" msgid="807214229604353614">"Zahtjev za otključavanje RUIM Hrpd-ja je neuspješan."</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_ERROR" msgid="8644184447744175747">"Zahtjev za otključavanje korporativnog RUIM-ja je neuspješan."</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_ERROR" msgid="3801002648649640407">"Zahtjev za otključavanje RUIM-a pružaoca usluge je neuspješan."</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_ERROR" msgid="707397021218680753">"Zahtjev za otključavanje RUIM-a je neuspješan."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_PUK_ERROR" msgid="894358680773257820">"Otključavanje PUK-om nije uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK_ERROR" msgid="352466878146726991">"Otključavanje PUK-om nije uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_PUK_ERROR" msgid="7353389721907138671">"Otključavanje PUK-om nije uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK_ERROR" msgid="2655263155490857920">"Otključavanje PUK-om nije uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_PUK_ERROR" msgid="6903740900892931310">"Otključavanje PUK-om nije uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_PUK_ERROR" msgid="5165901670447518687">"Otključavanje PUK-om nije uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_PUK_ERROR" msgid="2856763216589267623">"Otključavanje PUK-om nije uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_PUK_ERROR" msgid="817542684437829139">"Otključavanje PUK-om nije uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK_ERROR" msgid="5178635064113393143">"Otključavanje PUK-om nije uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_PUK_ERROR" msgid="5391587926974531008">"Otključavanje PUK-om nije uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_PUK_ERROR" msgid="4895494864493315868">"Otključavanje PUK-om nije uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_SPN_ERROR" msgid="9017576601595353649">"Zahtjev za otključavanje SPN-a je neuspješan."</string>
    <string name="PERSOSUBSTATE_SIM_SP_EHPLMN_ERROR" msgid="1116993930995545742">"Zahtjev za otključavanje ekvivalentnog kućnog PLMN-a pružaoca usluge je neuspješan."</string>
    <string name="PERSOSUBSTATE_SIM_ICCID_ERROR" msgid="7559167306794441462">"Zahtjev za otključavanja ICCID-a je neuspješan."</string>
    <string name="PERSOSUBSTATE_SIM_IMPI_ERROR" msgid="2782926139511136588">"Zahtjev za otključavanje IMPI-ja je neuspješan."</string>
    <string name="PERSOSUBSTATE_SIM_NS_SP_ERROR" msgid="1890493954453456758">"Zahtjev za otključavanje mrežne podgrupe pružaoca usluge je neuspješan."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUCCESS" msgid="4886243367747126325">"Otključavanje mreže na SIM-u je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_SUCCESS" msgid="4053809277733513987">"Otključavanje mrežne podgrupe na SIM-u je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_SUCCESS" msgid="8249342930499801740">"Otključavanje SIM-a pružaoca usluge je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_SUCCESS" msgid="2339794542560381270">"Otključavanje korporativnog SIM-a je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_SUCCESS" msgid="6975608174152828954">"Otključavanje SIM-a je uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_SUCCESS" msgid="2846699261330463192">"Otključavanje mreže 1 na RUIM-u je uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_SUCCESS" msgid="5335414726057102801">"Otključavanje mreže 2 na RUIM-u je uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_SUCCESS" msgid="8868100318474971969">"Otključavanje RUIM Hrpd-a je uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_SUCCESS" msgid="6020936629725666932">"Otključavanja RUIM-a pružaoca usluge je uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_SUCCESS" msgid="6944873647584595489">"Otključavanje korporativnog RUIM-a je uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_SUCCESS" msgid="2526483514124121988">"Otključavanje RUIM-a je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_PUK_SUCCESS" msgid="7662200333621664621">"Otključavanje PUK-om je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK_SUCCESS" msgid="2861223407953766632">"Otključavanje PUK-om je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_PUK_SUCCESS" msgid="5345648571175243272">"Otključavanje PUK-om je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK_SUCCESS" msgid="3725278343103422466">"Otključavanje PUK-om je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_PUK_SUCCESS" msgid="6998502547560297983">"Otključavanje PUK-om je uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_PUK_SUCCESS" msgid="8555433771162560361">"Otključavanje PUK-om je uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_PUK_SUCCESS" msgid="3555767296933606232">"Otključavanje PUK-om je uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_PUK_SUCCESS" msgid="6778051818199974237">"Otključavanje PUK-om je uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_PUK_SUCCESS" msgid="4080108758498911429">"Otključavanje PUK-om je uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK_SUCCESS" msgid="7873675303000794343">"Otključavanje PUK-om je uspjelo."</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_PUK_SUCCESS" msgid="1763198215069819523">"Otključavanje PUK-om je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_SPN_SUCCESS" msgid="2053891977727320532">"Otključavanje SPN-a je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_SP_EHPLMN_SUCCESS" msgid="8146602361895007345">"Otključavanje ekvivalentnog kućnog PLMN-a pružaoca usluge je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_ICCID_SUCCESS" msgid="8058678548991999545">"Otključavanje ICCID-a je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_IMPI_SUCCESS" msgid="2545608067978550571">"Otključavanje IMPI-ja je uspjelo."</string>
    <string name="PERSOSUBSTATE_SIM_NS_SP_SUCCESS" msgid="4352382949744625007">"Otključavanje mrežne podgrupe pružaoca usluge je uspjelo."</string>
    <string name="config_pdp_reject_dialog_title" msgid="4072057179246785727"></string>
    <string name="config_pdp_reject_user_authentication_failed" msgid="4531693033885744689"></string>
    <string name="config_pdp_reject_service_not_subscribed" msgid="8190338397128671588"></string>
    <string name="config_pdp_reject_multi_conn_to_same_pdn_not_allowed" msgid="6024904218067254186"></string>
    <string name="window_magnification_prompt_title" msgid="2876703640772778215">"Nove postavke uvećavanja"</string>
    <string name="window_magnification_prompt_content" msgid="8159173903032344891">"Sada možete uvećati dio ekrana"</string>
    <string name="turn_on_magnification_settings_action" msgid="8521433346684847700">"Uključite u Postavkama"</string>
    <string name="dismiss_action" msgid="1728820550388704784">"Odbaci"</string>
    <string name="sensor_privacy_start_use_mic_notification_content_title" msgid="2420858361276370367">"Deblokirajte mikrofon uređaja"</string>
    <string name="sensor_privacy_start_use_camera_notification_content_title" msgid="7287720213963466672">"Deblokirajte kameru uređaja"</string>
    <string name="sensor_privacy_start_use_notification_content_text" msgid="7595608891015777346">"Za aplikaciju &lt;b&gt;<xliff:g id="APP">%s</xliff:g>&lt;/b&gt; te sve aplikacije i usluge"</string>
    <string name="sensor_privacy_start_use_dialog_turn_on_button" msgid="7089318886628390827">"Deblokiraj"</string>
    <string name="sensor_privacy_notification_channel_label" msgid="936036783155261349">"Privatnost senzora"</string>
    <string name="splash_screen_view_icon_description" msgid="180638751260598187">"Ikona aplikacije"</string>
    <string name="splash_screen_view_branding_description" msgid="7911129347402728216">"Slika robne marke za aplikaciju"</string>
    <string name="view_and_control_notification_title" msgid="4300765399209912240">"Provjerite postavke pristupa"</string>
    <string name="view_and_control_notification_content" msgid="8003766498562604034">"<xliff:g id="SERVICE_NAME">%s</xliff:g> može pregledati i kontrolirati vaš ekran. Dodirnite da pregledate."</string>
    <string name="ui_translation_accessibility_translated_text" msgid="3197547218178944544">"<xliff:g id="MESSAGE">%1$s</xliff:g> – prevedeno."</string>
    <string name="ui_translation_accessibility_translation_finished" msgid="3057830947610088465">"Poruka je prevedena s jezika <xliff:g id="FROM_LANGUAGE">%1$s</xliff:g> na <xliff:g id="TO_LANGUAGE">%2$s</xliff:g>."</string>
    <string name="notification_channel_abusive_bg_apps" msgid="6092140213264920355">"Aktivnost u pozadini"</string>
    <string name="notification_title_abusive_bg_apps" msgid="994230770856147656">"Aplikacija troši bateriju"</string>
    <string name="notification_title_long_running_fgs" msgid="8170284286477131587">"Aplikacija je i dalje aktivna"</string>
    <string name="notification_content_abusive_bg_apps" msgid="5296898075922695259">"Aplikacija <xliff:g id="APP">%1$s</xliff:g> radi u pozadini. Dodirnite da upravljate potrošnjom baterije."</string>
    <string name="notification_content_long_running_fgs" msgid="8258193410039977101">"Aplikacija <xliff:g id="APP">%1$s</xliff:g> može uticati na vijek trajanja baterije. Dodirnite da pregledate aktivne aplikacije."</string>
    <string name="notification_action_check_bg_apps" msgid="4758877443365362532">"Provjerite aktivne aplikacije"</string>
    <string name="vdm_camera_access_denied" product="default" msgid="6102378580971542473">"Nije moguće pristupiti kameri telefona s uređaja <xliff:g id="DEVICE">%1$s</xliff:g>"</string>
    <string name="vdm_camera_access_denied" product="tablet" msgid="6895968310395249076">"Nije moguće pristupiti kameri tableta s uređaja <xliff:g id="DEVICE">%1$s</xliff:g>"</string>
    <string name="vdm_secure_window" msgid="161700398158812314">"Ovom ne možete pristupiti tokom prijenosa. Umjesto toga pokušajte na telefonu."</string>
    <string name="system_locale_title" msgid="711882686834677268">"Sistemski zadano"</string>
</resources>
