<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2007 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="yes" msgid="4676390750360727396">"Da"</string>
    <string name="no" msgid="6731231425810196216">"Ne"</string>
    <string name="create" msgid="3578857613172647409">"Kreiraj"</string>
    <string name="allow" msgid="3349662621170855910">"Dozvoli"</string>
    <string name="deny" msgid="6947806159746484865">"Odbij"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Nepoznato"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="7201398282729229649">
      <item quantity="one">Još <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> korak vas dijeli od toga da postanete programer.</item>
      <item quantity="few">Još <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> koraka vas dijele od toga da postanete programer.</item>
      <item quantity="other">Još <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> koraka vas dijeli od toga da postanete programer.</item>
    </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Sada ste programer!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Nema potrebe, već ste programer."</string>
    <string name="dev_settings_disabled_warning" msgid="4909448907673974370">"Prvo omogućite opcije za programere."</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Bežična veza i mreže"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Sistem"</string>
    <string name="radio_info_data_connection_enable" msgid="8656750679353982712">"Omogućite vezu za prijenos podataka"</string>
    <string name="radio_info_data_connection_disable" msgid="8541302390883231216">"Onemogućite podatkovnu mrežu"</string>
    <string name="volte_provisioned_switch_string" msgid="7979882929810283786">"VoLTE"</string>
    <string name="vt_provisioned_switch_string" msgid="7876998291744854759">"Video poziv obezbijeđen"</string>
    <string name="wfc_provisioned_switch_string" msgid="3985406545172898078">"WiFi poziv obezbijeđen"</string>
    <string name="eab_provisioned_switch_string" msgid="3482272907448592975">"EAB/Omogućeno prisustvo"</string>
    <string name="cbrs_data_switch_string" msgid="2811485394350106691">"Cbrs podaci"</string>
    <string name="dsds_switch_string" msgid="4832797810509029243">"Omogući DSDS"</string>
    <string name="dsds_dialog_title" msgid="4031918551366689574">"Ponovo pokrenuti uređaj?"</string>
    <string name="dsds_dialog_message" msgid="8593083316067158412">"Da promijenite ovu postavku, trebate ponovo pokrenuti uređaj."</string>
    <string name="dsds_dialog_confirm" msgid="2853118984344309612">"Ponovo pokreni"</string>
    <string name="dsds_dialog_cancel" msgid="654653450305828711">"Otkaži"</string>
    <string name="radio_info_radio_power" msgid="7187666084867419643">"Snaga mobilnog radija"</string>
    <string name="radioInfo_menu_viewADN" msgid="7069468158519465139">"Prikaži SIM adresar"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Prikaži brojeve fiksnog biranja"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Prikaži brojeve biranja usluga"</string>
    <string name="radioInfo_menu_getIMS" msgid="185171476413967831">"Status IMS usluge"</string>
    <string name="radio_info_ims_reg_status_title" msgid="16971785902696970">"Status za IMS"</string>
    <string name="radio_info_ims_reg_status_registered" msgid="5614116179751126247">"Registrirano"</string>
    <string name="radio_info_ims_reg_status_not_registered" msgid="4438054067642750717">"Nije registrirano"</string>
    <string name="radio_info_ims_feature_status_available" msgid="3687807290327566879">"Dostupno"</string>
    <string name="radio_info_ims_feature_status_unavailable" msgid="4606182208970114368">"Nedostupno"</string>
    <string name="radio_info_ims_reg_status" msgid="7534612158445529715">"IMS registracija: <xliff:g id="STATUS">%1$s</xliff:g>\nGovor putem LTE mreže: <xliff:g id="AVAILABILITY_0">%2$s</xliff:g>\nGovor putem WiFi mreže: <xliff:g id="AVAILABILITY_1">%3$s</xliff:g>\nVideo pozivanje: <xliff:g id="AVAILABILITY_2">%4$s</xliff:g>\nUT interfejs: <xliff:g id="AVAILABILITY_3">%5$s</xliff:g>"</string>
    <string name="radioInfo_service_in" msgid="1697703164394784618">"Aktivan"</string>
    <string name="radioInfo_service_out" msgid="7999094221728929681">"Ne radi"</string>
    <string name="radioInfo_service_emergency" msgid="6274434235469661525">"Samo pozivi za hitne slučajeve"</string>
    <string name="radioInfo_service_off" msgid="7536423790014501173">"Radio je isključen"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Roming"</string>
    <string name="radioInfo_roaming_not" msgid="4849214885629672819">"Nije u romingu"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"U stanju mirovanja"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Zvonjava"</string>
    <string name="radioInfo_phone_offhook" msgid="5873835692449118954">"Poziv je u toku"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Isključena"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Povezivanje"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Povezano"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Suspendirano"</string>
    <string name="radioInfo_unknown" msgid="1476509178755955088">"Nepoznato"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"paketi"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"bajtova"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Deaktiviraj USB pohranu"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Deaktiviraj SD karticu"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Izbriši USB pohranu"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Izbriši SD karticu"</string>
    <string name="preview_pager_content_description" msgid="8926235999291761243">"Pregled"</string>
    <string name="preview_page_indicator_content_description" msgid="4821343428913401264">"Pregled, strana <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> od <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="font_size_summary" msgid="1690992332887488183">"Smanjite ili povećajte tekst na ekranu."</string>
    <string name="font_size_make_smaller_desc" msgid="7919995133365371569">"Napravi manji"</string>
    <string name="font_size_make_larger_desc" msgid="4316986572233686061">"Napravi veći"</string>
    <!-- no translation found for font_size_preview_text (4818424565068376732) -->
    <skip />
    <string name="font_size_preview_text_headline" msgid="7955317408475392247">"Uzorak teksta"</string>
    <string name="font_size_preview_text_title" msgid="1310536233106975546">"Čarobnjak iz Oza"</string>
    <string name="font_size_preview_text_subtitle" msgid="4231671528173110093">"Poglavlje 11: Smaragdni grad Oz"</string>
    <string name="font_size_preview_text_body" msgid="2846183528684496723">"I pored toga što su im oči bile zaštićene zelenim naočalama, Dorothy i njeni prijatelji su isprva bili zaslijepljeni blještavilom tog grada. Ulicama su se nizale predivne zelene kuće izgrađene od zelenog mermera i obasute svjetlucavim smaragdima. Hodali su trotoarom od istog zelenog mermera, a na spoju između blokova nalazili su se usko postavljeni redovi smaragda koji su svjetlucali od sunčevog sjaja. Prozorska okna su bila od zelenog stakla. Čak je i nebo iznad grada imalo zeleni odsjaj, baš kao i sunčeve zrake. \n\nTu je bilo mnogo ljudi, muškaraca, žena i djece, šetali su odjeveni u zelenu odjeću i imali su zelenkastu kožu. S čuđenjem su gledali u Dodorthy i njenu čudnovatu družinu. Kada su vidjeli lava, sva djeca su pobjegla i sakrila se iza svoje majke; ali niko im se nije obraćao. Na ulici je bilo mnogo prodavnica, a Dorothy je vidjela da je u njima sve zeleno. U ponudi su bili zeleni slatkiši i zelene kokice, kao i zelene cipele, zeleni šeširi i raznorazna zelena odjeća. Na jednom mjestu čovjek je prodavao zelenu limunadu, a kada su je djeca kupovala, Dorothy je vidjela da plaćaju zelenim novčićima. \n\nKoliko se dalo primijetiti, tamo nije bilo konja ni bilo kojih drugih životinja, a muškarci su raznosili stvari pomoću zelenih kolica koja su gurali pred sobom. Svi su djelovali sretno, zadovoljno i uspješno."</string>
    <string name="font_size_save" msgid="3450855718056759095">"Uredu"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"USB pohrana"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"SD kartica"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"Vidljiv za sve obližnje Bluetooth uređaje (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Vidljiv za sve obližnje Bluetooth uređaje"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Nije vidljiv za druge Bluetooth uređaje"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Vidljiv samo za uparene uređaje"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Istek vremena za vidljivost"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Zaključaj glasovno biranje"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Spriječi korištenje bluetooth birača kada je ekran zaključan"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Bluetooth uređaji"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Naziv uređaja"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Postavke uređaja"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Postavke profila"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Nije postavljeno ime, koristi se ime računa"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Potraži uređaje"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Promijenite naziv uređaja"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Promijeni naziv"</string>
    <string name="bluetooth_disconnect_title" msgid="7830252930348734303">"Želite li prekinuti vezu s uređajem?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="8208712728668714199">"Vaš telefon će prekinuti vezu s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="tablet" msgid="6611038575213485336">"Vaš tablet će prekinuti vezu s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="device" msgid="3995834526315103965">"Vaš uređaj će prekinuti vezu s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="3308586619539119106">"Prekini vezu"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="603521233563983689">"Nemate odobrenje da mijenjate postavke za Bluetooth."</string>
    <string name="bluetooth_pairing_pref_title" msgid="7429413067477968637">"Uparivanje novog uređaja"</string>
    <string name="bluetooth_is_visible_message" msgid="6222396240776971862">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> je vidljiv uređajima u blizini, dok su postavke Bluetootha otvorene."</string>
    <string name="bluetooth_footer_mac_message" product="default" msgid="1109366350000220283">"Bluetooth adresa telefona: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="tablet" msgid="6807634484499166486">"Bluetooth adresa tableta: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="device" msgid="8413944740341742061">"Bluetooth adresa uređaja: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_is_disconnect_question" msgid="5334933802445256306">"Želite li prekinuti vezu sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Emitovanje"</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Neimenovani Bluetooth uređaj"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Pretraživanje"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"Nema Bluetooth uređaja u blizini."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Zahtjev za Bluetooth uparivanje"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Zahtjev za uparivanje"</string>
    <string name="bluetooth_notif_message" msgid="5057417127600942904">"Dodirnite za spajanje s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="3144149432555230410">"Primljeni fajlovi"</string>
    <string name="bluetooth_show_files_received_via_bluetooth" msgid="5445105773989432594">"Fajlovi primljeni putem Bluetootha"</string>
    <string name="device_picker" msgid="4978696506172252813">"Odaberi Bluetooth uređaj"</string>
    <string name="bluetooth_ask_enablement" msgid="3387222809404177525">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="5890386255790160573">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="1644353686104482763">"Aplikacija želi uključiti Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="9218830122674868548">"Aplikacija želi isključiti Bluetooth"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="4791779658660357386">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da vaš tablet bude vidljiv drugim uređajima sa Bluetoothom <xliff:g id="TIMEOUT">%2$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="1308225382575535366">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da vaš telefon bude vidljiv drugim uređajima sa Bluetoothom <xliff:g id="TIMEOUT">%2$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery_no_name" product="tablet" msgid="225715443477752935">"Aplikacija želi da vaš tablet bude vidljiv drugim uređajima sa Bluetoothom <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery_no_name" product="default" msgid="4949152735544109994">"Aplikacija želi da vaš telefon bude vidljiv drugim uređajima sa Bluetoothom <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8528329166577187961">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da vaš tablet bude vidljiv drugim Bluetooth uređajima. Ovo možete promijeniti kasnije u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="4398738575307583138">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi da vaš telefon bude vidljiv drugim Bluetooth uređajima. Ovo možete promijeniti kasnije u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet" msgid="1702590641426207062">"Aplikacija želi da vaš tablet bude vidljiv drugim Bluetooth uređajima. Ovo možete kasnije promijeniti u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="default" msgid="8549952177383992238">"Aplikacija želi da vaš telefon bude vidljiv drugim Bluetooth uređajima. Ovo možete promijeniti kasnije u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="1141843490422565755">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth te učiniti vaš tablet vidljivim drugim uređajima <xliff:g id="TIMEOUT">%2$d</xliff:g> s."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="5195836980079191473">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth te učiniti vaš telefon vidljivim drugim uređajima <xliff:g id="TIMEOUT">%2$d</xliff:g> s."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="tablet" msgid="7009338445281693765">"Aplikacija želi uključiti Bluetooth te učiniti vaš tablet vidljivim drugim uređajima <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="default" msgid="8386904242279878734">"Aplikacija želi uključiti Bluetooth te učiniti vaš telefon vidljivim drugim uređajima <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="2279471426575892686">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth i učiniti vaš tablet vidljivim drugim uređajima. Ovo možete kasnije promijeniti u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6961969825475461450">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti Bluetooth i učiniti vaš telefon vidljivim drugim uređajima. Ovo možete kasnije promijeniti u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="tablet" msgid="692477613671555006">"Aplikacija želi uključiti Bluetooth i učiniti vaš tablet vidljivim drugim uređajima. Ovo možete kasnije promijeniti u postavkama za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="default" msgid="6374480121751597648">"Aplikacija želi uključiti Bluetooth i učiniti vaš telefon vidljivim drugim uređajima. Ovo možete promijeniti kasnije u postavkama za Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Uključivanje funkcije Bluetooth…"</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Isključivanje funkcije Bluetooth…"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Zahtjev za uspostavljanje Bluetooth veze"</string>
    <string name="bluetooth_connection_notif_message" msgid="3603316575471431846">"Dodirnite za povezivanje s uređajem \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Da li se želite povezati na \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Zahtjev za pristup imeniku"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="8930347091018455505">"Uređaj <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi pristupiti vašim kontaktima i historiji poziva. Želite li odobriti pristup uređaju <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>?"</string>
    <string name="bluetooth_remember_choice" msgid="6919682671787049800">"Ne pitaj ponovo"</string>
    <string name="bluetooth_pb_remember_choice" msgid="3622898084442402071">"Ne pitaj ponovo"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Zahtjev za pristup porukama"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"%1$s želi pristupiti svojim porukama. Dozvoliti pristup za %2$s?"</string>
    <string name="bluetooth_sap_request" msgid="2669762224045354417">"Zahtjev za pristup SIM-u"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="4414253873553608690">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi pristupiti vašoj SIM kartici. Odobrenje pristupa SIM kartici će onemogućiti vezu za prijenos podataka na vašem uređaju za vrijeme trajanja veze. Odobri pristup uređaju <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g>"</string>
    <string name="bluetooth_device_name_summary" msgid="522235742194965734">"Uređaj je vidljiv drugim uređajima kao \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\""</string>
    <string name="bluetooth_off_footer" msgid="8406865700572772936">"Uključite Bluetooth za povezivanje s drugim uređajima."</string>
    <string name="bluetooth_paired_device_title" msgid="8638994696317952019">"Vaši uređaji"</string>
    <string name="bluetooth_pairing_page_title" msgid="7712127387361962608">"Uparivanje novog uređaja"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3520035819421024105">"Omogućite tabletu da komunicira s Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2205100629387332862">"Omogućite uređaju da komunicira s Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="782032074675157079">"Omogućite telefonu da komunicira s Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="4936610906348223810">"Onemogući rasterećenje Bluetootha A2DP"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title" msgid="4340101417209145308">"Ponovo pokrenuti?"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message" msgid="8827019472003234568">"Da promijenite ovu postavku, treba ponovo pokrenuti uređaj."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="2053793518537051975">"Pokreni opet"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="2382443064737856652">"Otkaži"</string>
    <string name="connected_device_available_media_title" msgid="2560067541413280645">"Dostupni mediji"</string>
    <string name="connected_device_available_call_title" msgid="697154660967595684">"Dostupni uređaji za pozivanje"</string>
    <string name="connected_device_connected_title" msgid="5871712271201945606">"Trenutno povezano"</string>
    <string name="connected_device_saved_title" msgid="688364359746674536">"Sačuvani uređaji"</string>
    <string name="connected_device_add_device_summary" msgid="4041865900298680338">"Bluetooth će se uključiti za uparivanje"</string>
    <string name="connected_device_connections_title" msgid="5988939345181466770">"Postavke veze"</string>
    <string name="connected_device_previously_connected_title" msgid="491765792822244604">"Prethodno povezani uređaji"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="6196066429488377795">"Prethodno povezani"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="5683648191381637533">"Bluetooth je uključen"</string>
    <string name="previous_connected_see_all" msgid="3626779872898778415">"Prikaži sve"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Datum i vrijeme"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Odaberite vremensku zonu"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Pošalji <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Pokreni <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Račun:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Proxy"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Obriši"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Priključak za proksi"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Zaobilazni proksi za"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Vrati na zadano"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Gotovo"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Proksi hostname"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Pažnja"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"Uredu"</string>
    <string name="proxy_error_invalid_host" msgid="6865850167802455230">"Uneseni naziv host računara nije važeći."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="678527645450894773">"Unesena lista isključenja nije odgovarajuće formatirana. Unesite listu isključenih domena u obliku liste stavki odvojenih zarezom."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Morate popuniti adresno polje"</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Adresno polje mora biti prazno ako je server polje prazno."</string>
    <string name="proxy_error_invalid_port" msgid="5988270202074492710">"Uneseni port nije važeći."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Preglednik koristi HTTP proksi, ali je moguće da ga ne koriste druge aplikacije."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"URL za PAC: "</string>
    <string name="radio_info_subid" msgid="204582608052503412">"Trenutni pomoćni ID:"</string>
    <string name="radio_info_dds" msgid="5471937791273237508">"Pomoćni ID za zadani podatkovni SIM:"</string>
    <string name="radio_info_dl_kbps" msgid="6894556071523815984">"DL propusnost (kbps):"</string>
    <string name="radio_info_ul_kbps" msgid="946464073571185678">"UL propusnost (kbps):"</string>
    <string name="radio_info_signal_location_label" msgid="3242990404410530456">"Informacije o lokaciji ćelije (zastarjele):"</string>
    <string name="radio_info_phy_chan_config" msgid="7133247058801474028">"Konfiguracija LTE fizičkog kanala:"</string>
    <string name="radio_info_cell_info_refresh_rate" msgid="7062777594049622128">"Interval osvježavanja informacija o ćeliji"</string>
    <string name="radio_info_cellinfo_label" msgid="6213223844927623098">"Sve informacije o mjerenju ćelije"</string>
    <string name="radio_info_gprs_service_label" msgid="4209624131644060517">"Prijenos podataka:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Roming:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="2743797189722106231">"Preusmjeravanje poziva:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3587319503902576102">"Broj vraćanja PPP na početne vrijednosti od posljednjeg pokretanja:"</string>
    <string name="radio_info_current_network_label" msgid="9151285540639134945">"Trenutna mreža:"</string>
    <string name="radio_info_ppp_received_label" msgid="363579470428151850">"Primljeni podaci:"</string>
    <string name="radio_info_gsm_service_label" msgid="1370863866816125489">"Govorna usluga:"</string>
    <string name="radio_info_signal_strength_label" msgid="5155734002519307416">"Jačina signala:"</string>
    <string name="radio_info_call_status_label" msgid="2611065018172747413">"Status glasovnog poziva:"</string>
    <string name="radio_info_ppp_sent_label" msgid="7748668735880404586">"Poslani podaci:"</string>
    <string name="radio_info_message_waiting_label" msgid="1037302619943328273">"Poruka na čekanju:"</string>
    <string name="radio_info_phone_number_label" msgid="7942153178953255231">"Telefonski broj:"</string>
    <string name="radio_info_band_mode_label" msgid="8730871744887454509">"Odaberite radijski opseg"</string>
    <string name="radio_info_voice_network_type_label" msgid="1443496502370667071">"Tip glasovne mreže:"</string>
    <string name="radio_info_data_network_type_label" msgid="7094323145105149312">"Tip podatkovne mreže:"</string>
    <string name="phone_index_label" msgid="1934407597576454430">"Odaberite indeks telefona"</string>
    <string name="radio_info_set_perferred_label" msgid="3511830813500105512">"Postavite preferiranu vrstu mreže:"</string>
    <string name="radio_info_ping_hostname_v4" msgid="7045103377818314709">"Pinguj ime računara (www.google.com) IPv4:"</string>
    <string name="radio_info_ping_hostname_v6" msgid="1130906124160553954">"Pinguj ime računara (www.google.com) IPv6:"</string>
    <string name="radio_info_http_client_test" msgid="2382286093023138339">"Test HTTP klijenta:"</string>
    <string name="ping_test_label" msgid="579228584343892613">"Pokreni ping test"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Ažuriraj"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Osvježi"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="6625185764803245075">"Prebaci provjeru DNS-a"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"OEM-specifične informacije/postavke"</string>
    <string name="band_mode_title" msgid="4071411679019296568">"Postavite način radijskog opsega"</string>
    <string name="band_mode_loading" msgid="3555063585133586152">"Učitavanje popisa opsega…"</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Postavi"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Neuspješno"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Uspješno"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Promjene stupaju na snagu kada se ponovo poveže USB kabl."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Omogući USB masovnu pohranu"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Ukupno bajtova:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"USB pohrana nije aktivirana."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Nema SD kartice."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Dostupno bajtova:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"USB memorija se koristi kao uređaj za masovnu pohranu."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"SD kartica se koristi kao uređaj za masovnu pohranu."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="5128923500235719226">"Sigurno je izbaciti USB."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="666233604712540408">"Sada je sigurno ukloniti SD karticu."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"USB pohr. ukl. dok se korist.!"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"SD kartica je uklonjena dok je još bila u upotrebi!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Iskorišteno bajtova:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Skenir. medija na USB pohrani…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Skeniranje medijskih sadržaja na SD kartici…"</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"USB pohr. je akt. samo za čit."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"SD kartica je aktivirana samo za čitanje."</string>
    <string name="skip_label" msgid="47510779345218297">"Preskoči"</string>
    <string name="next_label" msgid="4693520878012668114">"Naprijed"</string>
    <string name="language_picker_title" msgid="3596315202551687690">"Jezici"</string>
    <string name="locale_remove_menu" msgid="7651301406723638854">"Ukloni"</string>
    <string name="add_a_language" msgid="2330538812283783022">"Dodajte jezik"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="4276642359346122396">
      <item quantity="one">Ukloniti odabrane jezike?</item>
      <item quantity="few">Ukloniti odabrane jezike?</item>
      <item quantity="other">Ukloniti odabrane jezike?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="1361354927342876114">"Tekst će biti prikazan na drugom jeziku"</string>
    <string name="dlg_remove_locales_error_title" msgid="2653242337224911425">"Ne mogu se ukloniti svi jezici"</string>
    <string name="dlg_remove_locales_error_message" msgid="6697381512654262821">"Zadržite najmanje jedan preferirani jezik"</string>
    <string name="locale_not_translated" msgid="516862628177166755">"Možda nije dostupno u nekim aplikacijama"</string>
    <string name="action_drag_label_move_up" msgid="9052210023727612540">"Pomjeri prema gore"</string>
    <string name="action_drag_label_move_down" msgid="7448713844582912157">"Pomjeri prema dolje"</string>
    <string name="action_drag_label_move_top" msgid="557081389352288310">"Pomjeri na vrh"</string>
    <string name="action_drag_label_move_bottom" msgid="2468642142414126482">"Pomjeri na dno"</string>
    <string name="action_drag_label_remove" msgid="2861038147166966206">"Ukloni jezik"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Odaberite aktivnost"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Informacije o uređaju"</string>
    <string name="display_label" msgid="8074070940506840792">"Ekran"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Informacije o tabletu"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informacije o telefonu"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"USB pohrana"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"SD kartica"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Postavke proksija"</string>
    <string name="cancel" msgid="6859253417269739139">"Otkaži"</string>
    <string name="okay" msgid="1997666393121016642">"Uredu"</string>
    <string name="forget" msgid="1400428660472591263">"Zaboravi"</string>
    <string name="save" msgid="879993180139353333">"Sačuvaj"</string>
    <string name="done" msgid="6942539184162713160">"Gotovo"</string>
    <string name="apply" msgid="1577045208487259229">"Primijeni"</string>
    <string name="share" msgid="6791534619806355910">"Dijeli"</string>
    <string name="add" msgid="3709942705501136412">"Dodaj"</string>
    <string name="settings_label" msgid="1626402585530130914">"Postavke"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Postavke"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Prečica za postavke"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Način rada u avionu"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Bežična veza i mreže"</string>
    <string name="radio_controls_summary" msgid="1838624369870907268">"Upravljanje značajkama Wi-Fi, Bluetooth, način rada u zrakoplovu, mobilne mreže i VPN-ovi"</string>
    <string name="cellular_data_title" msgid="6835451574385496662">"Prijenos podataka na mobilnoj mreži"</string>
    <string name="calls_title" msgid="1262096900483238572">"Dozvoli pozive"</string>
    <string name="sms_messages_title" msgid="1778636286080572535">"SMS poruke"</string>
    <string name="cellular_data_summary" msgid="4660351864416939504">"Dopusti prijenos podataka mobilnom mrežom"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Dozvoli prijenos podataka u romingu"</string>
    <string name="roaming" msgid="2619521775007402005">"Roming"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Povezivanje na usluge prijenosa podataka u romingu"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Povezivanje na usluge prijenosa podataka u romingu"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Ostali ste bez veze za prijenos podataka jer ste napustili matičnu mrežu dok je roming podataka isključen."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Uključi"</string>
    <string name="roaming_warning" msgid="4275443317524544705">"Može doći do značajnih troškova."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Ako dozvolite prijenos podataka u romingu, može doći do značajnih troškova rominga!\n\nOva postavka utječe na sve korisnike na ovom tabletu."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Kada dozvolite podatkovni roming mogu nastati značajni troškovi !\n\nOva postavka se odnosi na sve korisnike telefona."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Dozvoliti roming podataka?"</string>
    <string name="networks" msgid="6333316876545927039">"Izbor operatera"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Odaberite operatera"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Datum i vrijeme"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Postavljanje datuma i vremena"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Postavljanje datuma, vremena, vremenske zone i formata"</string>
    <string name="date_time_auto" msgid="4290527098376721491">"Koristi vrijeme koje definira mreža"</string>
    <string name="zone_auto_title" msgid="3217703906014135437">"Koristi vremensku zonu koju definira mreža"</string>
    <string name="date_time_24hour_auto" msgid="6276269188890332084">"Koristi lokalni zadani format"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"24-satni format"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Koristi 24-satni format"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Vrijeme"</string>
    <string name="time_format_category_title" msgid="736190761036057769">"Format vremena"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Vremenska zona"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Odabir vremenske zone"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Datum"</string>
    <string name="date_time_search_region" msgid="2478334699004021972">"Pretražite regiju"</string>
    <string name="date_time_select_region" msgid="5434001881313168586">"Regija"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="6084375085203448645">"Odaberite odstupanje od UTC-a"</string>
    <string name="zone_change_to_from_dst" msgid="118656001224045590">"<xliff:g id="TIME_TYPE">%1$s</xliff:g> počinje <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="1359698475641349336">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="164876167707284017">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer" msgid="4192803402331390389">"Koristi <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="DST_TIME_TYPE">%2$s</xliff:g> počinje <xliff:g id="TRANSITION_DATE">%3$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8652423870143056964">"Koristi <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Ne koristi ljetno računanje vremena."</string>
    <string name="zone_time_type_dst" msgid="8850494578766845276">"Ljetno računanje vremena"</string>
    <string name="zone_time_type_standard" msgid="3462424485380376522">"Standardno vrijeme"</string>
    <string name="zone_menu_by_region" msgid="8370437123807764346">"Odabir prema regiji"</string>
    <string name="zone_menu_by_offset" msgid="7161573994228041794">"Odabir prema odstup. od UTC-a"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Datum"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Vrijeme"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Automatsko zaključavanje"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> nakon stanja mirovanja"</string>
    <string name="lock_immediately_summary_with_exception" msgid="9119632173886172690">"Odmah nakon mirovanja, osim kada ga <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> drži otključanim"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="5579064842797188409">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> nakon mirovanja, osim kada <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> održava status nezaključano"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Prikaži informacije o vlasniku na zaključanom ekranu"</string>
    <string name="owner_info_settings_title" msgid="5530285568897386122">"Poruka na zaključanom ekranu"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Omogući vidžete"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="6392489775303464905">"Onemogućio administrator"</string>
    <string name="lockdown_settings_title" msgid="7393790212603280213">"Prikaži opciju zaključavanja"</string>
    <string name="lockdown_settings_summary" msgid="429230431748285997">"Prikaži opciju dugmeta za uključivanje koja isključuje Smart Lock, otključavanje otiskom prsta i obavještenja na zaključanom ekranu."</string>
    <string name="trust_agents_extend_unlock_title" msgid="2796555263565097031">"Pouzdani agenti produžuju otključavanje"</string>
    <string name="trust_agents_extend_unlock_summary" msgid="3976344969220255010">"Ako je omogućeno, pouzdani agenti će vaš uređaj držati otključanim duže, ali ne mogu otključati zaključan uređaj."</string>
    <string name="trust_lost_locks_screen_title" msgid="2992742466966021682">"Zaključan ekran kad nema pouzdanosti"</string>
    <string name="trust_lost_locks_screen_summary" msgid="693784434582021206">"Ako je omogućeno, uređaj će se zaključati kad zadnji pouzdani agent više ne bude pouzdan"</string>
    <string name="owner_info_settings_summary" msgid="7472393443779227052">"Ništa"</string>
    <string name="owner_info_settings_status" msgid="120407527726476378">"<xliff:g id="COUNT_0">%1$d</xliff:g>/<xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="7591869574491036360">"Npr. Edinov Android."</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Podaci o korisniku"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Prikazuj informacije o profilu na zaključ. ekranu"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Podaci o profilu"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Računi"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Lokacija"</string>
    <string name="location_settings_master_switch_title" msgid="3560242980335542411">"Koristi lokaciju"</string>
    <string name="location_settings_summary_location_off" msgid="794370259612167176">"Isključeno"</string>
    <plurals name="location_settings_summary_location_on" formatted="false" msgid="5222949914335428617">
      <item quantity="one">Uključeno – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikacija može pristupiti lokaciji</item>
      <item quantity="few">Uključeno – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikacije mogu pristupiti lokaciji</item>
      <item quantity="other">Uključeno – <xliff:g id="COUNT_1">%1$d</xliff:g> aplikacija može pristupiti lokaciji</item>
    </plurals>
    <string name="location_settings_loading_app_permission_stats" msgid="8523775367089431611">"Učitavanje…"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Računi"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Sigurnost"</string>
    <string name="encryption_and_credential_settings_title" msgid="6514904533438791561">"Šifriranje i akreditivi"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="8721883002237981248">"Telefon je šifriran"</string>
    <string name="decryption_settings_summary" product="default" msgid="5671817824042639849">"Telefon nije šifriran"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="7200428573872395685">"Uređaj je šifriran"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="5794135636155570977">"Uređaj nije šifriran"</string>
    <string name="lockscreen_settings_title" msgid="1099738951060387656">"Prikaz zaključavanja ekrana"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="278055252361575926">"Šta prikazati"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Postavite Moju lokaciju, otključavanje ekrana, zaključavanje SIM kartice, zaključavanje pohrane akreditiva"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Postavite Moju lokaciju, otključavanje ekrana, zaključavanje pohrane akreditiva"</string>
    <string name="security_passwords_title" msgid="2881269890053568809">"Privatnost"</string>
    <string name="disabled_by_administrator_summary" msgid="1601828700318996341">"Onemogućio administrator"</string>
    <string name="security_status_title" msgid="5848766673665944640">"Sigurnosni status"</string>
    <string name="security_dashboard_summary_face" msgid="268234254306703218">"Zaključavanje ekrana, otključavanje licem"</string>
    <string name="security_dashboard_summary" msgid="6757421634477554939">"Zaključavanje ekrana, otisak prsta"</string>
    <string name="security_dashboard_summary_no_fingerprint" msgid="8129641548372335540">"Zaključavanje ekrana"</string>
    <string name="security_settings_face_preference_summary" msgid="1290187225482642821">"Lice je dodano"</string>
    <string name="security_settings_face_preference_summary_none" msgid="5460349732790152186">"Dodirnite da postavite autentifikaciju licem"</string>
    <string name="security_settings_face_preference_title" msgid="7074548721778680481">"Autentifikacija licem"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="7784083491315229721">"Koristi postavku za pristupačnost"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="4455532390587307262"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7075186169796301461"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="4277182322482408514">"Otkaži"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="2694505011712885439">"Otključajte pomoću lica"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="8180330567034286589">"Koristite lice za autentifikaciju"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="6150611993438981458">"Koristite lice za otključavanje telefona, odobravanje kupovine ili prijavu u aplikacije."</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="6393270235632444857">"Koristite lice za otključavanje telefona ili odobravanje kupovina.\n\nNapomena: ne možete koristiti lice za otključavanje ovog uređaja. Za više informacija obratite se administratoru svoje organizacije."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="5704661081718707858">"Koristite lice za otključavanje telefona, odobravanje kupovine ili prijavu u aplikacije."</string>
    <string name="security_settings_face_enroll_introduction_footer_message" msgid="6129862379306304035"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4019853239039918762">"Namjestite lice u centar kruga"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="1933553314312349529">"Uradit ću to kasnije"</string>
    <string name="face_add_max" msgid="4408683751143942949">"Možete dodati najviše <xliff:g id="COUNT">%d</xliff:g> lica"</string>
    <string name="face_intro_error_max" msgid="160022811747660581">"Dodali ste maksimalan broj lica"</string>
    <string name="face_intro_error_unknown" msgid="6367721696446677261">"Nije moguće dodati više lica"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2869110702072655323">"Registracija nije dovršena"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="2980238861223265089">"UREDU"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="1701191960569185087">"Vrijeme za snimanje lica je isteklo. Pokušajte ponovo."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3825066262969499407">"Upis lica nije uspio."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="8268014305067971249">"Sve je spremno. Izgleda dobro."</string>
    <string name="security_settings_face_enroll_done" msgid="6670735678797960484">"Gotovo"</string>
    <string name="security_settings_face_settings_use_face_category" msgid="4102604281840004724">"Koristite lice za"</string>
    <string name="security_settings_face_settings_use_face_unlock_phone" msgid="5275635645351823301">"Otključavanje uređaja"</string>
    <string name="security_settings_face_settings_use_face_for_apps" msgid="5751549943998662469">"Prijava u aplikaciju i plaćanja"</string>
    <string name="security_settings_face_settings_require_attention" msgid="1638445716306615123">"Otvorite oči za otključavanje"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="5749808567341263288">"Pri korištenju autentifikacije licem morate držati oči otvorenim"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="2559602923985027572">"Uvijek traži potvrdu"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="2002651109571928756">"Prilikom autentifikacije u aplikacijama uvijek zahtijevajte potvrdu"</string>
    <string name="security_settings_face_settings_remove_face_data" msgid="3477772641643318370">"Ukloni podatke o licu"</string>
    <string name="security_settings_face_settings_footer" msgid="8056977398747222768">"Možete koristiti lice da otključate uređaje i pristupite aplikacijama. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="4829278778459836075">"Izbrisati podatke o licu?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="2609671025686003946">"Podaci koje je zabilježilo otključavanje licem izbrisat će se trajno i sigurno. Nakon uklanjanja, trebat će vam PIN, uzorak ili lozinka za otključavanje telefona, prijavu u aplikacije i potvrdu plaćanja."</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2488725232406204350">"Otisak prsta"</string>
    <string name="fingerprint_manage_category_title" msgid="8293801041700001681">"Upravljanje otiscima prstiju"</string>
    <string name="fingerprint_usage_category_title" msgid="8438526918999536619">"Koristi otisak za"</string>
    <string name="fingerprint_add_title" msgid="1926752654454033904">"Dodaj otisak prsta"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5078060939636911795">"zaključavanje ekrana"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="624961700033979880">
      <item quantity="one"><xliff:g id="COUNT_1">%1$d</xliff:g> otisak prsta je postavljen</item>
      <item quantity="few"><xliff:g id="COUNT_1">%1$d</xliff:g> otiska prsta su postavljena</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> otisaka prstiju je postavljeno</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1507739327565151923"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="3201556857492526098">"Otključavanje otiskom prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="7066417934622827305">"Koristite otisak prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="3508870672887336095">"Samo dodirnite senzor za otisak prsta da otključate telefon, odobrite kupovinu ili da se prijavite u aplikaciju. Pazite čije otiske prsta dodajete. Samo jedan dodani otisak može izvršiti sve navedeno.\n\nNapomena: Vaš otisak prsta može biti manje siguran od jakog uzorka ili PIN-a."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="1550756694054944874">"Pomoću otiska prsta otključavajte telefon ili odobravajte kupovinu.\n\nNapomena: otisak prsta ne možete koristiti za otključavanje ovog uređaja. Za više informacija, obratite se administratoru svoje organizacije"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="6817326798834882531">"Pomoću otiska prsta otključavajte telefon ili odobravajte kupovinu.\n\nNapomena: otisak vašeg prsta može biti manje siguran od jakog uzorka ili PIN-a."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="3199351118385606526">"Otkaži"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="7472492858148162530">"Nastavi"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup" msgid="5021369420474432665">"Preskoči"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup" msgid="1961957425135180242">"Naprijed"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="362050541117362034">"Preskočiti otisak prsta?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="958990414356204763">"Postavljanje otiska prsta traje svega minut ili dva. Ako ovo preskočite, otisak prsta možete dodati kasnije u postavkama."</string>
    <string name="lock_screen_intro_skip_title" msgid="4988210105913705679">"Preskočiti zaključani ekran?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1581834104051243425">"Funkcije za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge osobe da koriste ovaj tablet ako ga izgubite, ako vam ga ukradu ili ga vratite na početne postavke."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="4629503416877189572">"Funkcije za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge osobe da koriste ovaj uređaj ako ga izgubite, ako vam ga ukradu ili ga vratite na početne postavke."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="2423428240245737909">"Funkcije za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge osobe da koriste ovaj telefon ako ga izgubite, ako vam ga ukradu ili ga vratite na početne postavke."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="5219287483885558525">"Funkcije za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge osobe da koriste ovaj tablet ako ga izgubite ili vam ga ukradu."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="1466238255429527112">"Funkcije za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge osobe da koriste ovaj uređaj ako ga izgubite ili vam ga ukradu."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="3008526710555416125">"Funkcije za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge osobe da koriste ovaj telefon ako ga izgubite ili vam ga ukradu."</string>
    <string name="skip_anyway_button_label" msgid="2323522873558834513">"Ipak preskoči"</string>
    <string name="go_back_button_label" msgid="4745265266186209467">"Nazad"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="7478349557867790778">"Preskoči"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="4525833484240246349">"Otkaži"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="3051496861358227199">"Dodirnite senzor"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="8793966374365960368">"Nalazi se na poleđini telefona. Koristite kažiprst."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="2058830032070449160">"Ilustracija sa uređajem i lokacijom senzora za otisak prsta"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7086763077909041106">"Ime"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4150384963879569750">"Uredu"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="4114615413240707936">"Izbriši"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="2068961812439460133">"Dodirnite senzor"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="3909929328942564524">"Stavite prst na senzor i podignite ga kad osjetite vibraciju"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="2819679722403209778">"Podignite i ponovo dodirnite"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="6158989350522518586">"Nastavite podizati prst da dodate različite dijelove otiska prsta"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="7567276170287972230">"Dodan je otisak prsta"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="8970048776120548976">"Kada vidite ovu ikonu, koristite otisak prsta za identifikaciju ili odobravanje kupovine."</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3710211704052369752">"Uradit ću to kasnije"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="6808422329107426923">"Preskočiti postavljanje otiska prsta?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="274849306857859783">"Odabrali ste da koristite otisak prsta kao jedan od načina za otključavanja telefona. Ukoliko sada preskočite ovaj korak, morat ćete ga postaviti kasnije. Postavka traje otprilike samo jednu minutu."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="tablet" msgid="5925427033028514518">"Zaštitite tablet zaključavanjem ekrana tako da ga niko ne može koristiti ako ga izgubite ili vam ga ukradu. Zaključavanje ekrana vam je potrebno i za postavljanje otiska prsta. Dodirnite Otkaži, a zatim postavite PIN ili odaberite drugu opciju zaključavanja ekrana."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="device" msgid="2524729541954689407">"Zaštitite uređaj zaključavanjem ekrana tako da ga niko ne može koristiti ako ga izgubite ili vam ga ukradu. Zaključavanje ekrana vam je potrebno i za postavljanje otiska prsta. Dodirnite Otkaži, a zatim postavite PIN ili odaberite drugu opciju zaključavanja ekrana."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="default" msgid="2941592649076449189">"Zaštitite telefon zaključavanjem ekrana tako da ga niko ne može koristiti ako ga izgubite ili vam ga ukradu. Zaključavanje ekrana vam je potrebno i za postavljanje otiska prsta. Dodirnite Otkaži, a zatim postavite PIN ili odaberite drugu opciju zaključavanja ekrana."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="tablet" msgid="2062547634035791832">"Zaštitite tablet zaključavanjem ekrana tako da ga niko ne može koristiti ako ga izgubite ili vam ga ukradu. Zaključavanje ekrana vam je potrebno i za postavljanje autentifikacije licem. Dodirnite Otkaži, a zatim postavite PIN ili odaberite drugu opciju zaključavanja ekrana."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="device" msgid="5844241782080551234">"Zaštitite uređaj zaključavanjem ekrana tako da ga niko ne može koristiti ako ga izgubite ili vam ga ukradu. Zaključavanje ekrana vam je potrebno i za postavljanje autentifikacije licem. Dodirnite Otkaži, a zatim postavite PIN ili odaberite drugu opciju zaključavanja ekrana."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="default" msgid="7605324540825242057">"Zaštitite telefon zaključavanjem ekrana tako da ga niko ne može koristiti ako ga izgubite ili vam ga ukradu. Zaključavanje ekrana vam je potrebno i za postavljanje autentifikacije licem. Dodirnite Otkaži, a zatim postavite PIN ili odaberite drugu opciju zaključavanja ekrana."</string>
    <!-- no translation found for lock_screen_pin_skip_title (8064328201816780457) -->
    <skip />
    <!-- no translation found for lock_screen_password_skip_title (4155009417576409182) -->
    <skip />
    <!-- no translation found for lock_screen_pattern_skip_title (6467327818577283960) -->
    <skip />
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="1195743489835505376">"Postavi zaključavanje ekrana"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="4014607378328187567">"Gotovo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="1863561601428695160">"Ups, to nije senzor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="2989019978041986175">"Dodirnite senzor na poleđini telefona. Koristite kažiprst."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="3618021988442639280">"Registracija nije dovršena"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="2942551158278899627">"Vrijeme za uzimanje otiska prsta je isteklo. Pokušajte ponovo."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="3624760637222239293">"Registracija otiska prsta nije uspjela. Pokušajte ponovo ili koristite drugi prst."</string>
    <string name="fingerprint_enroll_button_add" msgid="6317978977419045463">"Dodaj još jedan"</string>
    <string name="fingerprint_enroll_button_next" msgid="6247009337616342759">"Naprijed"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="2624905914239271751">"Osim otključavanja telefona, otisak prsta takođe možete koristiti za odobravanje kupovine i pristup aplikacijama. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="7846871823167357942">" Opcija zaključavanja ekrana je onemogućena. Da saznate više, obratite se administratoru organizacije. "<annotation id="admin_details">"Više informacija"</annotation>\n\n"I dalje možete koristiti otisak prsta za odobravanje kupovine i pristup aplikacijama. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="1888772560642539718">"Podignite prst, zatim ponovo dodirnite senzor"</string>
    <string name="fingerprint_add_max" msgid="1020927549936895822">"Možete dodati do <xliff:g id="COUNT">%d</xliff:g> otisaka prstiju"</string>
    <string name="fingerprint_intro_error_max" msgid="6864066984678078441">"Dodali ste maksimalan broj otisaka prstiju"</string>
    <string name="fingerprint_intro_error_unknown" msgid="1905692132326523040">"Nije moguće dodati još otisaka prstiju"</string>
    <string name="fingerprint_last_delete_title" msgid="6410310101247028988">"Ukloniti sve otiske prstiju?"</string>
    <string name="fingerprint_delete_title" msgid="1368196182612202898">"Ukloni \'<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\'"</string>
    <string name="fingerprint_delete_message" msgid="8597787803567398131">"Želite li izbrisati ovaj otisak prsta?"</string>
    <string name="fingerprint_last_delete_message" msgid="7852321001254275878">"Otiske prstiju nećete moći koristiti za otključavanje telefona, odobravanje kupovine ili prijavljivanje u aplikacije"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="6521520787746771912">"Otiske prstiju nećete moći koristiti za otključavanje radnog profila, odobravanje kupovine ili prijavljivanje u radne aplikacije"</string>
    <string name="fingerprint_last_delete_confirm" msgid="2634726361059274289">"Da, ukloni"</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Šifriranje"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Šifriraj tablet"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Šifriranje telefona"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Šifrirano"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="503014594435731275">"Možete šifrirati svoje račune, postavke, preuzete aplikacije i njihove podatke, medijske podatke i druge fajlove. Nakon šifriranja tableta, uz pretpostavku da ste postavili zaključavanje ekrana (tj. postavili uzorak, numerički PIN ili lozinku), bit će potrebno da otključate ekran prilikom svakog uključivanja kako biste izvršili dešifriranje. Jedina alternativa dešifriranju je ponovno postavljanje na fabričke postavke uz brisanje svih vaših podataka.\n\nZa šifriranje je potreban jedan sat ili duže. Morate započeti sa napunjenom baterijom, a tablet treba biti priključen na napajanje tokom cijelog postupka. U slučaju prekida, izgubit ćete jedan dio ili sve svoje podatke"</string>
    <string name="crypt_keeper_desc" product="default" msgid="2579929266645543631">"Možete šifrirati svoje račune, postavke, preuzete aplikacije i njihove podatke, medijske sadržaje i druge fajlove. Nakon šifriranja telefona, uz pretpostavku da ste postavili zaključavanje ekrana (tj. postavili uzorak, numerički PIN ili lozinku), bit će potrebno da otključate ekran prilikom svakog uključivanja kako biste izvršili dešifriranje. Jedina alternativa dešifriranju je ponovno postavljanje na fabričke postavke uz brisanje svih vaših podataka.\n\nZa šifriranje je potreban jedan sat ili duže. Morate započeti sa napunjenom baterijom, a telefon treba biti priključen na napajanje tokom cijelog postupka. U slučaju prekida, izgubit ćete jedan dio ili sve svoje podatke."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Šifriraj tablet"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Šifriraj telefon"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Napunite bateriju i pokušajte ponovo."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Priključite punjač i pokušajte ponovo."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Nema PIN-a ili lozinke za zaključavanje ekrana"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Trebate postaviti PIN za zaključavanje ekrana ili lozinku da biste mogli pokrenuti šifriranje."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Šifriraj?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="517662068757620756">"Postupak šifriranja je neopoziv te gubite podatke u slučaju prekida. Šifriranje traje jedan sat ili duže, pri čemu se tablet ponovo pokreće nekoliko puta."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="287503113671320916">"Postupak šifriranja je nepovratan; u slučaju prekida, gubite podatke. Šifriranje traje jedan sat ili duže, pri čemu se telefon ponovo pokreće nekoliko puta."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Šifriranje"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Pričekajte dok se tablet šifrira. Dovršeno <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Pričekajte dok se telefon šifrira. Dovršeno <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="1655047311546745695">"Pričekajte dok se tablet šifrira. Preostalo vrijeme: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="1862964662304683072">"Pričekajte dok se telefon šifrira. Preostalo vrijeme: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="556504311511212648">"Da biste otključali tablet, isključite ga, zatim ponovo uključite."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="1794353635603020327">"Da biste otključali tablet, isključite ga, a zatim ponovo uključite."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"Upozorenje: Preostalo vam je <xliff:g id="COUNT">^1</xliff:g> pokušaja otključavanja, nakon čega će sadržaj vašeg uređaja biti izbrisan!"</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Otkucajte lozinku"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Šifriranje nije uspjelo"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="8219375738445017266">"Šifriranje je prekinuto te se ne može završiti. Zbog toga podaci sa vašeg tableta više nisu dostupni. \n\n Da biste nastavili koristiti tablet, treba da izvršite vraćanje tableta na fabričke postavke. Nakon što izvršite postavke tableta nakon vraćanja na fabričke postavke, moći ćete vratiti sve podatke za koje postoji sigurnosna kopija na Google računu."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3270131542549577953">"Šifriranje je prekinuto te se ne može završiti. Zbog toga podaci sa vašeg telefona više nisu dostupni. \n\nDa biste nastavili koristiti telefon, treba da izvršite vraćanje telefona na fabričke postavke. Nakon što izvršite postavke telefona nakon vraćanja na fabričke postavke, moći ćete vratiti sve podatke za koje postoji sigurnosna kopija na Google računu."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="8759119849089795751">"Dešifriranje nije uspjelo"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="840107296925798402">"Unesena lozinka je ispravna, ali nažalost vaši podaci su oštećeni. \n\nDa biste nastavili koristiti tablet, morate izvršiti vraćanje na fabričke postavke. Prilikom podešavanja tableta nakon ponovnog postavljanja, imat ćete priliku da vratite podatke čija sigurnosna kopija je spremljena u vaš Google račun."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="8843311420059663824">"Unesena lozinka je ispravna, ali nažalost vaši podaci su oštećeni. \n\nDa biste nastavili koristiti telefon, morate izvršiti vraćanje na fabričke postavke. Prilikom podešavanja telefona nakon ponovnog postavljanja, imat ćete priliku da vratite podatke čija sigurnosna kopija je spremljena u vaš Google račun."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Promjena načina unosa"</string>
    <string name="suggested_lock_settings_title" msgid="8498743819223200961">"Zaštitite telefon"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="2296800316150748710">"Postavite zaključavanje ekrana da zaštitite tablet"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="7562847814806365373">"Postavite zaključavanje ekrana da zaštitite uređaj"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="1526355348444658181">"Postavite zaključavanje ekrana da zaštitite telefon"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="2174553391551398081">"Dodajte otisak prsta da otključate"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="5738274583658668124"></string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Zaključavanje ekrana"</string>
    <string name="lock_settings_picker_title_profile" msgid="8822511284992306796">"Odaberi zaklj. profila"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="90329443364067215">"Zaštitite svoj tablet"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="2399952075134938929">"Zaštitite svoj uređaj"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="1572244299605153324">"Zaštitite svoj telefon"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1507307757032207572">"Za dodatnu sigurnost, postavite alternativni način zaključavanja ekrana"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="8919671129189936210">"Spriječite da druge osobe koriste ovaj tablet bez vašeg odobrenja tako što ćete aktivirati funkcije za zaštitu uređaja. Odaberite koji način zaključavanja ekrana želite koristiti."</string>
    <string name="setup_lock_settings_picker_message" product="device" msgid="3787276514406353777">"Spriječite da druge osobe koriste ovaj uređaj bez vašeg odobrenja tako što ćete aktivirati funkcije za zaštitu uređaja. Odaberite koji način zaključavanja ekrana želite koristiti."</string>
    <string name="setup_lock_settings_picker_message" product="default" msgid="3692856437543730446">"Spriječite da druge osobe koriste ovaj telefon bez vašeg odobrenja tako što ćete aktivirati funkcije za zaštitu uređaja. Odaberite koji način zaključavanja ekrana želite koristiti."</string>
    <string name="lock_settings_picker_fingerprint_message" msgid="4755230324778371292">"Odaberite alternativni način zaključavanja ekrana"</string>
    <string name="lock_settings_picker_face_message" msgid="197106534637556054">"Odaberite alternativni način zaključavanja ekrana"</string>
    <string name="setup_lock_settings_options_button_label" msgid="8511153243629402929">"Opcije zaključavanja ekrana"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="5058207955455973917">"Opcije zaključavanja ekrana"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Zaključavanje ekrana"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5967714169972542586">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / odmah nakon izlaska iz stanja mirovanja"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_after_timeout" msgid="4696710373399258413">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / <xliff:g id="TIMEOUT_STRING">%2$s</xliff:g> nakon izlaska iz stanja mirovanja"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="124176557311393483">"Zaključ. radnog prof."</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Promijeni zaključavanje ekrana"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Promijeni ili onemog. uzorak, PIN ili lozinku"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Odaberite način za zaključavanje ekrana"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Ništa"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Prevlačenje prstom"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Nema sigurnosti"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Uzorak"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Srednja sigurnost"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Srednja do visoka sigurnost"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Lozinka"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Visoka sigurnost"</string>
    <string name="unlock_set_do_later_title" msgid="4894767558414979243">"Ne sada"</string>
    <string name="current_screen_lock" msgid="4104091715420072219">"Trenutni način zaključavanja ekrana"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4939057588092120368">"Otisak prsta i uzorak"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="8010746824051056986">"Otisak prsta i PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="7351131075806338634">"Otisak prsta i lozinka"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="1441077909803666681">"Nastavi bez postavljanja otiska prsta"</string>
    <string name="fingerprint_unlock_title" msgid="2826226740306003991">"Možete otključati telefon pomoću otiska prsta. Iz sigurnosnih razloga, ova opcija zahtijeva alternativni način zaključavanja ekrana."</string>
    <string name="face_unlock_set_unlock_pattern" msgid="8792301636367000123">"Autentifikacija licem + uzorak"</string>
    <string name="face_unlock_set_unlock_pin" msgid="1196620299595657479">"Autentifikacija licem + PIN"</string>
    <string name="face_unlock_set_unlock_password" msgid="223117276773907474">"Autentifikacija licem + lozinka"</string>
    <string name="face_unlock_skip_face" msgid="6362883392838482791">"Nastavi bez autentifikacije licem"</string>
    <string name="face_unlock_title" msgid="9042382084472444316">"Možete otključati telefon pomoću svog lica. Iz sigurnosnih razloga, ova opcija zahtijeva alternativni način zaključavanja ekrana."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2051593894736282302">"Onemogućio administrator, pravila šifriranja ili pohrana akreditiva"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Ništa"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Prevlačenje prstom"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Uzorak"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Lozinka"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="7893457665921363009">"Kada postavite zaključavanje ekrana, možete postaviti i otisak prsta u Postavke i Sigurnost."</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Isključi zaključavanje ekrana"</string>
    <string name="unlock_disable_frp_warning_title" msgid="264008934468492550">"Ukloniti zaštitu uređaja?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="5507136301904313583">"Želite li ukloniti zaštitu profila?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="8869767290771023461">"Funkcije za zaštitu uređaja neće funkcionirati bez uzorka."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2986105377420905314">"Funkcije za zaštitu uređaja neće raditi bez uzorka.<xliff:g id="EMPTY_LINE">

</xliff:g>Vaši sačuvani otisci prstiju također će se ukloniti iz ovog uređaja i nećete ih moći koristiti za otključavanje telefona, odobravanje kupovine ili prijavljivanje u aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="586996206210265131">"Funkcija zaštite uređaja neće raditi bez PIN-a."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="3370462835533123695">"Funkcije za zaštitu uređaja neće raditi bez PIN-a.<xliff:g id="EMPTY_LINE">

</xliff:g>Vaši sačuvani otisci prstiju također će se ukloniti iz ovog uređaja i nećete ih moći koristiti za otključavanje telefona, odobravanje kupovine ili prijavljivanje u aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="5420612686852555537">"Funkcija zaštite uređaja neće raditi bez lozinke."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="3595476296430536798">"Funkcije za zaštitu uređaja neće raditi bez lozinke.<xliff:g id="EMPTY_LINE">

</xliff:g>Vaši sačuvani otisci prstiju također će se ukloniti iz ovog uređaja i nećete ih moći koristiti za otključavanje telefona, odobravanje kupovine ili prijavljivanje u aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="1550718040483548220">"Funkcija zaštite uređaja neće raditi bez zaključavanja ekrana."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="3679351662094349506">"Funkcije za zaštitu uređaja neće raditi bez zaključavanja ekrana.<xliff:g id="EMPTY_LINE">

</xliff:g>Vaši sačuvani otisci prstiju također će se ukloniti iz ovog uređaja i nećete ih moći koristiti za otključavanje telefona, odobravanje kupovine ili prijavljivanje u aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_pattern_profile" msgid="8682200103576359918">"Funkcije za zaštitu profila neće funkcionirati bez uzorka."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile" msgid="6718155854303231675">"Funkcije za zaštitu profila neće raditi bez uzorka.<xliff:g id="EMPTY_LINE">

</xliff:g>Vaši sačuvani otisci prstiju također će se ukloniti iz ovog profila i nećete ih moći koristiti za otključavanje profila, odobravanje kupovine ili prijavljivanje u aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_pin_profile" msgid="7790688070593867767">"Funkcije za zaštitu profila neće funkcionirati bez PIN-a."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile" msgid="4209564603132870532">"Funkcije za zaštitu profila neće raditi bez PIN-a.<xliff:g id="EMPTY_LINE">

</xliff:g>Vaši sačuvani otisci prstiju također će se ukloniti iz ovog profila i nećete ih moći koristiti za otključavanje profila, odobravanje kupovine ili prijavljivanje u aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_password_profile" msgid="7569285520567674461">"Funkcije za zaštitu profila neće funkcionirati bez lozinke."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile" msgid="2994300676764706047">"Funkcije za zaštitu profila neće raditi bez lozinke.<xliff:g id="EMPTY_LINE">

</xliff:g>Vaši sačuvani otisci prstiju također će se ukloniti iz ovog profila i nećete ih moći koristiti za otključavanje profila, odobravanje kupovine ili prijavljivanje u aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_unknown_profile" msgid="6984215718701688202">"Funkcije za zaštitu profila neće funkcionirati bez zaključavanja ekrana."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile" msgid="4994062501123299418">"Funkcije za zaštitu profila neće raditi bez zaključavanja ekrana.<xliff:g id="EMPTY_LINE">

</xliff:g>Vaši sačuvani otisci prstiju također će se ukloniti iz ovog profila i nećete ih moći koristiti za otključavanje profila, odobravanje kupovine ili prijavljivanje u aplikacije."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="7075138677177748705">"Da, ukloni"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Promijeni uzorak za otključavanje"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Prom. PIN za otključ."</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Promijeni lozinku za otključavanje"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="7529087063617325912">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> predlaže jak PIN ili lozinku, a moguće je da neće funkcionirati kako je očekivano ako to ne postavite"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="4195620619469851350">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> predlaže novi PIN ili lozinku, a moguće je da neće funkcionirati kako je očekivano ako to ne postavite"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="428655972363263817">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> predlaže novi uzorak, PIN ili lozinku, a moguće je da neće funkcionirati kako je očekivano ako to ne postavite"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="6275441987228550440">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> predlaže novo zaključavanje ekrana"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="2219711062197089783">"Pokušajte ponovo. <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g>. od <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g> pokušaja."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="4277765862798876826">"Vaši podaci će se izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="1688030823464420974">"Ako u sljedećem pokušaju unesete neispravan obrazac, podaci ovog uređaja će se izbrisati"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="5350785938296254352">"Ako u sljedećem pokušaju unesete neispravan PIN, podaci ovog uređaja će se izbrisati"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="6208035114731421034">"Ako u sljedećem pokušaju unesete neispravnu lozinku, podaci ovog uređaja će se izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="7851504071368235547">"Ako u sljedećem pokušaju unesete neispravan obrazac, ovaj korisnik će se izbrisati"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="4049024921333961715">"Ako u sljedećem pokušaju unesete neispravan PIN, ovaj korisnik će se izbrisati"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="4660886542496781672">"Ako u sljedećem pokušaju unesete neispravnu lozinku, ovaj korisnik će se izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2437716252059050291">"Ako u sljedećem pokušaju unesete neispravan obrazac, vaš radni profil i njegovi podaci će se izbrisati"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="5799931839127476913">"Ako u sljedećem pokušaju unesete neispravan PIN, vaš radni profil i njegovi podaci će se izbrisati"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="6786586046975042158">"Ako u sljedećem pokušaju unesete neispravnu lozinku, vaš radni profil i njegovi podaci će se izbrisati"</string>
    <string name="lock_failed_attempts_now_wiping_device" msgid="5047439819181833824">"Previše je neispravnih pokušaja. Podaci ovog uređaja će se izbrisati."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="6188180643494518001">"Previše je neispravnih pokušaja. Ovaj korisnik će se izbrisati."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="1745475043685915442">"Previše je neispravnih pokušaja. Ovaj poslovni profil i njegovi podaci će se izbrisati."</string>
    <string name="lock_failed_attempts_now_wiping_dialog_dismiss" msgid="8246716090548717312">"Odbaci"</string>
    <plurals name="lockpassword_password_too_short" formatted="false" msgid="1957883871187697796">
      <item quantity="one">Mora sadržavati najmanje <xliff:g id="COUNT_1">%d</xliff:g> znak</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT_1">%d</xliff:g> znaka</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT_1">%d</xliff:g> znakova</item>
    </plurals>
    <plurals name="lockpassword_pin_too_short" formatted="false" msgid="5019935246875659237">
      <item quantity="one">PIN mora sadržavati najmanje <xliff:g id="COUNT_1">%d</xliff:g> cifru</item>
      <item quantity="few">PIN mora sadržavati najmanje <xliff:g id="COUNT_1">%d</xliff:g> cifre</item>
      <item quantity="other">PIN mora sadržavati najmanje <xliff:g id="COUNT_1">%d</xliff:g> cifara</item>
    </plurals>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Nastavi"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="4581209996591221075">
      <item quantity="one">Ukupan broj znakova mora biti manji od <xliff:g id="NUMBER_1">%d</xliff:g></item>
      <item quantity="few">Ukupan broj znakova mora biti manji od <xliff:g id="NUMBER_1">%d</xliff:g></item>
      <item quantity="other">Ukupan broj znakova mora biti manji od <xliff:g id="NUMBER_1">%d</xliff:g></item>
    </plurals>
    <plurals name="lockpassword_pin_too_long" formatted="false" msgid="185568652740755131">
      <item quantity="one">Ukupan broj cifara mora biti manji od <xliff:g id="NUMBER_1">%d</xliff:g></item>
      <item quantity="few">Ukupan broj cifara mora biti manji od <xliff:g id="NUMBER_1">%d</xliff:g></item>
      <item quantity="other">Ukupan broj cifara mora biti manji od <xliff:g id="NUMBER_1">%d</xliff:g></item>
    </plurals>
    <string name="lockpassword_pin_contains_non_digits" msgid="7284664023164191198">"Mora sadržavati isključivo cifre 0-9."</string>
    <string name="lockpassword_pin_recently_used" msgid="1401569207976460727">"Administrator uređaja ne dozvoljava korištenje nedavnog PIN-a"</string>
    <string name="lockpassword_pin_blacklisted_by_admin" msgid="8563366383328811472">"Vaš IT administrator je blokirao česte PIN kôdove. Probajte drugi PIN kôd."</string>
    <string name="lockpassword_illegal_character" msgid="8049611046639943217">"Ne može sadržavati nevažeći znak"</string>
    <string name="lockpassword_password_requires_alpha" msgid="3036589522150097731">"Mora sadržavati najmanje jedno slovo"</string>
    <string name="lockpassword_password_requires_digit" msgid="5140062925787058765">"Mora sadržavati najmanje jednu cifru"</string>
    <string name="lockpassword_password_requires_symbol" msgid="5944350865681510893">"Mora sadržavati najmanje jedan simbol"</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="9013132344745898400">
      <item quantity="one">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> slovo</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> slova</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> slova</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="2626327674921055486">
      <item quantity="one">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> malo slovo</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> mala slova</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> malih slova</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="7860796359913920356">
      <item quantity="one">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> veliko slovo</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> velika slova</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> velikih slova</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="1967587658356336828">
      <item quantity="one">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> cifru</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> cifre</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> cifara</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="6751305770863640574">
      <item quantity="one">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> posebni znak</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> posebna znaka</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> posebnih znakova</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="4440596998172043055">
      <item quantity="one">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> znak koji nije slovo</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> znaka koja nisu slova</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> znakova koji nisu slova</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="942665351220525547">"Administrator uređaja ne dozvoljava korištenje nedavne lozinke"</string>
    <string name="lockpassword_password_blacklisted_by_admin" msgid="9105101266246197027">"Vaš IT administrator je blokirao česte lozinke. Probajte drugu lozinku."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="680765285206990584">"Nije dozvoljen rastući, opadajući ili ponavljajući niz cifara"</string>
    <string name="lockpassword_confirm_label" msgid="8176726201389902380">"Potvrdi"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Otkaži"</string>
    <string name="lockpassword_clear_label" msgid="5724429464960458155">"Obriši"</string>
    <string name="lockpassword_credential_changed" msgid="581649578639853343">"Zaključavanje ekrana je već promijenjeno. Pokušajte ponovo s novim zaključavanjem ekrana."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Otkaži"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Naprijed"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Postavljanje je završeno."</string>
    <string name="manage_device_admin" msgid="537804979483211453">"Aplikacije administratora uređaja"</string>
    <string name="number_of_device_admins_none" msgid="7185056721919496069">"Nema aktivnih aplikacija"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="3361891840111523393">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> aktivna aplikacija</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> aktivne aplikacije</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aktivnih aplikacija</item>
    </plurals>
    <string name="manage_trust_agents" msgid="4629279457536987768">"Pouzdani agenti"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Da biste koristili, prvo postavite zaključavanje ekrana"</string>
    <string name="manage_trust_agents_summary" msgid="1475819820389620546">"Nema"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="3935182396726101824">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aktivni pouzdani agent</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aktivna pouzdana agenta</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aktivnih pouzdanih agenata</item>
    </plurals>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Uključi Bluetooth"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Upravljajte vezama, postavite ime uređaja i vidljivost"</string>
    <string name="bluetooth_pairing_request" msgid="2605098826364694673">"Upariti sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="418124944140102021">"Kod za Bluetooth uparivanje"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Upišite kod za uparivanje, zatim pritisnite Return ili Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"PIN sadrži slova ili simbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Obično 0000 ili 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="7849359451584101077">"Mora imati 16 znamenki"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Možda ćete morati otkucati ovaj PIN i na drugom uređaju."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Možda ćete morati otkucati ovaj pristupni kôd na drugom uređaju."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Da biste izvršilu uparivanje s uređajem:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Provjerite da li se prikazuje sljedeći pristupni ključ:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"Od:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Želite izvršiti uparivanje s ovim uređajem?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Da biste izvršili uparivanje s uređajem:<xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Otkucajte na njemu:<xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g>, a zatim pritisnite Return ili Enter."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="9082518313285787097">"Dozvolite pristup kontaktima i historiji poziva"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_connecting_error_message" msgid="1397388344342081090">"Nije uspjelo povezivanje sa uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Potraži uređaje"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Osvježi"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Pretraživanje…"</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Postavke uređaja"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Upareni uređaj"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Internet veza"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Tastatura"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Kontakti i historija poziva"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Upariti sa ovim uređajem?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Podijeliti telefonski imenik?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> želi pristupiti vašim kontaktima i historiji poziva."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="8451248193517851958">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> želi uparivanje putem Bluetootha. Nakon povezivanja imat će pristup vašim kontaktima i historiji poziva."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="1617401232446299411">"Dostupni uređaji"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"Nema dostupnih uređaja"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Poveži se"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Prekini vezu"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Upari i poveži"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Prekini uparivanje"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Prekini vezu i uparivanje"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Opcije..."</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Napredno"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Napredni Bluetooth"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Kada je Bluetooth uključen, uređaj može komunicirati s drugim uređajima s Bluetoothom u blizini."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="824285504325592644">"Kada je uključen Bluetooth, uređaj može komunicirati s Bluetooth uređajima u blizini.\n\nZa bolji doživljaj korištenja uređaja, aplikacije i usluge i dalje mogu u bilo koje vrijeme skenirati uređaje u blizini, čak i kada je Bluetooth isključen. Ovo se može koristiti, naprimjer, za poboljšanje funkcija i usluga zasnovanih na lokaciji. Ovo možete promijeniti u meniju "<annotation id="link">"postavke skeniranja"</annotation>"."</string>
    <string name="ble_scan_notify_text" msgid="1295915006005700650">"Radi poboljšanja preciznosti lociranja, sistemske aplikacije i usluge i dalje mogu prepoznati uređaje s Bluetoothom. Ovo možete promijeniti u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama skeniranja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_failed" msgid="4500234659813241053">"Nije povezan. Pokušajte ponovo."</string>
    <string name="device_details_title" msgid="6576953269221085300">"Detalji o uređaju"</string>
    <string name="bluetooth_device_mac_address" msgid="2513724313558236181">"Bluetooth adresa uređaja: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="38467834196432400">"Želite li zaboraviti uređaj?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="9087609557757135712">"Vaš telefon neće više biti uparen s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="tablet" msgid="7785695793007576501">"Vaš tablet neće više biti uparen s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="device" msgid="251257782642157557">"Vaš uređaj neće više biti uparen s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="3829370108973879006">"Zaboravi uređaj"</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Poveži se na…"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"Veza uređaja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> sa zvukom medija će biti prekinuta."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"Veza uređaja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> sa handsfree zvukom će biti prekinuta."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"Veza uređaja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> s ulaznim uređajem će biti prekinuta."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Pristup internetu preko uređaja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> će biti prekinut."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="8355910926439312604">"Prekinut će se veza s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g> za dijeljenje internetske veze ovog tableta."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="6251611115860359886">"Prekinut će se veza s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g> za dijeljenje internetske veze ovog telefona."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Upareni Bluetooth uređaj"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Poveži se"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Poveži se s Bluetooth uređajem"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Koristi se za"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Promijeni naziv"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Dozvoli dolazne transfere fajlova"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="6436258151814414028">"Povezano na uređaj za pristup internetu"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1322694224800769308">"Dijeljenje lokalne internetske veze s uređajem"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Postavke priključne stanice"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Koristi priključnu stanicu za zvuk"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Kao spikerfon"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Za muziku i medijske sadržaje"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Zapamti postavke"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="6752690395207847881">"Maksimalan broj povezanih Bluetooth audio uređaja"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="5936561749790095473">"Odaberite maksimalan broj povezanih Bluetooth audio uređaja"</string>
    <string name="wifi_display_settings_title" msgid="8740852850033480136">"Emitiranje"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Omogući bežični prikaz"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"Nije pronađen nijedan uređaj u blizini."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Povezuje se"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Povezano"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"U upotrebi"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Nedostupan"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Postavke ekrana"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Opcije Bežičnog prikaza"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Zaboraviti"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Gotovo"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Ime"</string>
    <string name="wifi_band_24ghz" msgid="852929254171856911">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="6433822023268515117">"5 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8404345621836792112">"Prijava"</string>
    <string name="wifi_tap_to_sign_in" msgid="6990161842394669054">"Dodirnite ovdje za prijavu na mrežu"</string>
    <string name="tx_link_speed" msgid="6139577455916971837">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="rx_link_speed" msgid="5729003360923133988">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="wifi_ask_enable" msgid="2795469717302060104">"<xliff:g id="REQUESTER">%s</xliff:g> želi uključiti WiFi"</string>
    <string name="wifi_ask_disable" msgid="728366570145493573">"<xliff:g id="REQUESTER">%s</xliff:g> želi isključiti WiFi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="6029838014407791341">"Potvrdi bajtni kôd aplikacija iz kojih se mogu uklanjati greške"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="2250352478065428399">"Dopustite ART-u da potvrdi bajtni kôd za aplikacije iz kojih se mogu uklanjati greške"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Dopusti razmjenu podataka kada tablet dodirne drugi uređaj"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Omogućavanje razmjene podataka kada telefon dodirne drugi uređaj"</string>
    <string name="nfc_disclaimer_title" msgid="4364003873202264039">"Uključite NFC"</string>
    <string name="nfc_disclaimer_content" msgid="5566907911915158075">"NFC razmjenjuje podatke između ovog i drugih uređaja ili ciljeva u blizini, kao što su terminali za plaćanje, čitači pristupa i interaktivni oglasi ili oznake."</string>
    <string name="nfc_secure_settings_title" msgid="150400737244061585">"Osiguraj NFC"</string>
    <string name="nfc_secure_toggle_summary" product="default" msgid="2135032222065627938">"Dozvoli NFC plaćanje i korištenje u javnom prijevozu samo kada je ekran otključan"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Spremno za prijenos sadržaja aplikacije putem NFC-a"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Isključeno"</string>
    <string name="nfc_disabled_summary" msgid="3507017304297395467">"Nedostupno jer je NFC isključen"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="1810540319385192758">"Kada je uključena ova funkcija, možete emitirati sadržaj aplikacije na drugi uređaj koji podržava NFC približavanjem uređaja jedan drugome. Naprimjer, možete emitirati web stranice, videozapise s YouTubea, kontakte i drugo.\n\nSamo približite uređaje jedan drugome (u pravilu, poleđinu uz poleđinu) a zatim dodirnite svoj ekran. Aplikacija će sama prepoznati šta treba emitirati."</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"Wi‑Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Uključite Wi‑Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi‑Fi"</string>
    <string name="wifi_settings_master_switch_title" msgid="4746267967669683259">"Koristi WiFi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"WiFi postavke"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"WiFi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Podešavanje bežičnih pristupnih tačaka i upravljanje njima"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Odaberite WiFi"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Uključivanje WiFi..."</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Isključivanje WiFi..."</string>
    <string name="wifi_error" msgid="3207971103917128179">"Greška"</string>
    <string name="wifi_sap_no_channel_error" msgid="3108445199311817111">"Opseg od 5 GHz nije dostupan u ovoj zemlji"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"U načinu rada u avionu"</string>
    <string name="wifi_notify_open_networks" msgid="76298880708051981">"Obavještenja o otvorenim mrežama"</string>
    <string name="wifi_notify_open_networks_summary" msgid="2761326999921366960">"Obavijesti me kada bude dostupna javna mreža visokog kvaliteta"</string>
    <string name="wifi_wakeup" msgid="8815640989361538036">"Automatski uključi WiFi"</string>
    <string name="wifi_wakeup_summary" msgid="2530814331062997163">"WiFi se automatski ponovo uključuje u blizini sačuvanih mreža visokog kvaliteta, kao što je kućna mreža"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="7494539594649967699">"Nije dostupno jer je lokacija isključena. Uključite "<annotation id="link">"lokaciju"</annotation>"."</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="7247227922074840445">"Nije dostupno jer je skeniranje WiFi mreže isključeno"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="108339002136866897">"Za korištenje funkcije odaberite ocjenjivača mreže"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Izbjegavaj slabe veze"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7016103106105907127">"Ne koristi WiFi mrežu, osim ako je internetska veza dobra"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="1644292503152790501">"Korištenje samo mreža koje imaju dobru internetsku vezu"</string>
    <string name="use_open_wifi_automatically_title" msgid="6851951242903078588">"Poveži se s otvorenim mrežama"</string>
    <string name="use_open_wifi_automatically_summary" msgid="2982091714252931713">"Automatsko povezivanje na javne mreže visokog kvaliteta"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="593964217679325831">"Za korištenje funkcije odaberite ocjenjivača mreže"</string>
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled" msgid="8472122600853650258">"Za korištenje funkcije odaberite kompatibilnog ocjenjivača mreže"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Instaliranje certifikata"</string>
    <string name="wifi_scan_notify_text" msgid="5544778734762998889">"Kako bi poboljšale preciznost lokacije, aplikacije i usluge mogu i dalje uvijek skenirati WiFi mreže, čak i kada je WiFi isključen. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji. Ovo možete izmijeniti u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama skeniranja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="3426075479272242098">"Radi poboljšanja preciznosti lociranja, uključite skeniranje WiFi mreža u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama skeniranja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="7104867814641144485">"Ne prikazuj ponovo"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Zadrži WiFi uključenim tokom mirovanja"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"WiFi za vrijeme mirovanja"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Pojavio se problem prilikom mijenjanja postavke"</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Poboljšaj učinkovitost"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimizacija WiFi-ja"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Minimiziraj potrošnju baterije kad je WiFi uključen"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Limit za bateriju za WiFi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="8593144541347373394">"Prebaci se na prijenos podataka na mobilnoj mreži ako WiFi izgubi pristup internetu."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="8753386877755616476">"Automatsko prebacivanje na prijenos podataka na mobilnoj mreži"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="1403505355490119307">"Korištenje prijenosa podataka na mobilnoj mreži kada WiFi mreža nema pristup internetu. Mogu nastati troškovi prijenosa podataka."</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Dodaj mrežu"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2913345003906899146">"Postavke za WiFi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="646393113104367290">"Wi‑Fi veza se uključuje ponovo automatski"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="2782566279864356713">"WiFi se ne uključuje ponovo automatski"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"WiFi mreže"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Više opcija"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"WiFi Direct"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Skeniraj"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Napredno"</string>
    <string name="wifi_menu_configure" msgid="6150926852602171938">"Konfiguriraj"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Poveži se na mrežu"</string>
    <string name="wifi_menu_remember" msgid="8814185749388713796">"Zapamti mrežu"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Zaboravi mrežu"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Modificiraj mrežu"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Da biste vidjeli dostupne mreže, uključite WiFi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Traži se WiFi mreža..."</string>
    <string name="wifi_empty_list_user_restricted" msgid="7322372065475939129">"Nemate odobrenje za promjenu WiFi mreže."</string>
    <string name="wifi_more" msgid="3195296805089107950">"Još"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Autom. postavljanje (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="3815269816331500375">"Uključiti skeniranje WiFi mreže?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="6352918945128328916">"Za automatsko uključivanje WiFi mreže, prvo morate uključiti skeniranje WiFi mreže."</string>
    <string name="wifi_settings_scanning_required_info" msgid="3155631874578023647">"Skeniranje WiFi mreže omogućava aplikacijama i uslugama skeniranje WiFi mreža u svakom trenutku, čak i kada je WiFi mreža isključena. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1364287182804820646">"Uključi"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="5527653791584018157">"Skeniranje WiFi mreže je isključeno"</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Napredne opcije"</string>
    <string name="wifi_advanced_toggle_description_expanded" msgid="2380600578544493084">"Padajući spisak Naprednih opcija. Kliknite dvaput za sužavanje spiska."</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="1463812308429197263">"Padajući spisak Naprednih opcija. Kliknite dvaput za proširenje."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Ime mreže"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Unesite SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Sigurnost"</string>
    <string name="wifi_hidden_network" msgid="973162091800925000">"Skrivena mreža"</string>
    <string name="wifi_hidden_network_warning" msgid="6674068093531603452">"Ukoliko ruter ne emitira ID mreže, ali biste se u buduće željeli povezati na njega, možete postaviti mrežu kao skrivenu.\n\nNa taj način sigurnost može biti ugrožena jer će telefon redovno emitirati signal da pronađe mrežu.\n\nPostavljenjem mreže kao skrivene neće se promijeniti postavke vašeg rutera."</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Jačina signala"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Status"</string>
    <string name="tx_wifi_speed" msgid="2994278184097786511">"Brzina prijenosa veze"</string>
    <string name="rx_wifi_speed" msgid="7206089638282839236">"Primite info. o brzini veze"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Frekvencija"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"IP adresa"</string>
    <string name="passpoint_label" msgid="6381371313076009926">"Sačuvano pomoću"</string>
    <string name="passpoint_content" msgid="8447207162397870483">"<xliff:g id="NAME">%1$s</xliff:g> – vjerodajnice"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"EAP metoda"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Autentifikacija Faza 2"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"CA certifikat"</string>
    <string name="wifi_eap_domain" msgid="8471124344218082064">"Domena"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Korisnički certifikat"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identitet"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Anonimni identitet"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Lozinka"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Prikaži lozinku"</string>
    <string name="wifi_ap_band_config" msgid="1611826705989117930">"Odaberite opseg pristupne tačke"</string>
    <string name="wifi_ap_choose_auto" msgid="2677800651271769965">"Automatski"</string>
    <string name="wifi_ap_choose_2G" msgid="8724267386885036210">"Opseg od 2.4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8813128641914385634">"Opseg od 5,0 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2501070491623803139">"Preferira se opseg od 5,0 GHz"</string>
    <string name="wifi_ap_2G" msgid="8378132945192979364">"2,4 GHz"</string>
    <string name="wifi_ap_5G" msgid="4020713496716329468">"5,0 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="3476254666116431650">"Odaberite barem jedan frekvencijski pojas za Wi‑Fi pristupnu tačku:"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"IP postavke"</string>
    <string name="wifi_privacy_settings" msgid="5500777170960315928">"Privatnost"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="1539659414108891004">"Nasumično odabrani MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="8674936581557695411">"Dodajte uređaj"</string>
    <string name="wifi_dpp_center_qr_code" msgid="6244508369721032655">"Centrirajte QR kôd ispod da uređaj dodate na mrežu “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="4794621158747044107">"Skeniraj QR kôd"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="4371771604088014396">"Centrirajte QR kôd ispod da se povežete na mrežu “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="8096370383700478819">"Skenirajte QR kôd da se pridružite WiFi mreži"</string>
    <string name="wifi_dpp_share_wifi" msgid="9065890131734833809">"Dijeli WiFi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="5854392840857123065">"Skenirajte ovaj QR kôd da se povežete na mrežu “<xliff:g id="SSID">%1$s</xliff:g>” i dijelite lozinku"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="4436318319178361543">"Skenirajte ovaj QR kôd da se povežete na mrežu “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_could_not_detect_valid_qr_code" msgid="641893675646330576">"Očivatanje QR kôda nije uspjelo. Centrirajte kôd i pokušajte ponovo"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="3372757783382381044">"Pokušajte ponovo. Ako se problem ne riješi, kontaktirajte proizvođača uređaja"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="2829930473520603740">"Nešto nije uredu"</string>
    <string name="wifi_dpp_failure_timeout" msgid="5228320772245820458">"Provjerite je li uređaj priključen, napunjen i uključen"</string>
    <string name="wifi_dpp_failure_generic" msgid="8030831192606098356">"Provjerite je li uređaj priključen, napunjen i uključen. Ako se problem ne riješi, kontaktirajte proizvođača uređaja"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2643768115109632725">"Ovaj uređaj ne podržava dodavanje mreže“<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="2632966336733361805">"Provjerite vezu i pokušajte ponovo"</string>
    <string name="wifi_dpp_choose_network" msgid="7139308800110200281">"Odaberite mrežu"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4025269026652486605">"Za povezivanje uređaja, odaberite mrežu"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5459084866460319042">"Dodati ovaj uređaj na mrežu “<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="7669684043486750097">"Wi‑Fi mreža je podijeljena s uređajem"</string>
    <string name="wifi_dpp_add_another_device" msgid="8415243205104666929">"Dodaj još jedan uređaj"</string>
    <string name="wifi_dpp_choose_different_network" msgid="4081965219206680361">"Odaberi drugu mrežu"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="1598945041477461501">"Uređaj se ne može dodati"</string>
    <string name="wifi_dpp_device_found" msgid="8618134150169810107">"Uređaj je pronađen"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="5579154298588011712">"Dijeljenje WiFi mreže s ovim uređajem…"</string>
    <string name="wifi_dpp_connecting" msgid="7111851118215580428">"Povezivanje…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="762408459341741405">"Dijeljenje pristupne tačke"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="8401802203867904622">"Potvrdite da ste to vi"</string>
    <string name="wifi_dpp_wifi_password" msgid="4938294574591503213">"WiFi lozinka: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="4120419278831581613">"Lozinka pristupne tačke: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_add_device" msgid="4072206063308645677">"Dodajte uređaj"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="8898075663321081592">"Povežite se na ovu mrežu koristeći QR kôd"</string>
    <string name="retry" msgid="6472609612090877557">"Pokušaj ponovo"</string>
    <string name="wifi_shared" msgid="844142443226926070">"Dijeli s ostalim korisnicima uređaja"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(nepromijenjeno)"</string>
    <string name="wifi_unspecified" msgid="4917316464723064807">"Odaberite"</string>
    <string name="wifi_multiple_cert_added" msgid="3240743501460165224">"(dodano je više certifikata)"</string>
    <string name="wifi_use_system_certs" msgid="5270879895056893783">"Upotreba certifikata sistema"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="5160499244977160665">"Ne navodi"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4266754430576348471">"Ne potvrđuj valjanost"</string>
    <string name="wifi_do_not_validate_eap_server_warning" msgid="1787190245542586660">"Nije naveden certifikat. Veza neće biti privatna."</string>
    <string name="wifi_ssid_too_long" msgid="3474753269579895244">"Naziv mreže je predug."</string>
    <string name="wifi_no_domain_warning" msgid="5223011964091727376">"Morate navesti domenu."</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WPS dostupan"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (WPS dostupan)"</string>
    <string name="wifi_carrier_connect" msgid="8174696557882299911">"WiFi mreža mobilnog operatera"</string>
    <string name="wifi_carrier_content" msgid="4634077285415851933">"Povežite se preko mobilnog operatera <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Da biste poboljšali preciznost lokacije te u druge svrhe, <xliff:g id="APP_NAME">%1$s</xliff:g> aplikacija želi uključiti skeniranje mreže, čak i kada je WiFi isključen.\n\nŽelite li dozvoliti ovo za sve aplikacije koje žele izvršiti skeniranje?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="6162424298483845679">"Da bi poboljšala preciznost lokacije te u druge svrhe, nepoznata aplikacija želi uključiti skeniranje mreže, čak i kada je WiFi isključen.\n\nDozvoliti ovo za sve aplikacije koje žele skenirati?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="5538901671131941043">"Da ovo isključite, idite na Napredno u preklopnom meniju."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Dozvoli"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Odbij"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Prijavite se za povezivanje?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"<xliff:g id="APP_NAME">%1$s</xliff:g> zahtijeva da se prijavite online prije nego se povežete na mrežu."</string>
    <string name="wifi_hotspot_connect" msgid="5065506390164939225">"POVEZATI"</string>
    <string name="no_internet_access_text" msgid="5926979351959279577">"Ova mreža nema pristup internetu. Zadržati povezanost?"</string>
    <string name="partial_connectivity_text" msgid="1287030663891772340">"Neke aplikacije i usluge možda neće raditi zbog ograničene povezivosti. Ipak koristiti?"</string>
    <string name="no_internet_access_remember" msgid="4697314331614625075">"Ne pitaj me više za ovu mrežu"</string>
    <string name="lost_internet_access_title" msgid="5779478650636392426">"WiFi mreža nije povezana na internet"</string>
    <string name="lost_internet_access_text" msgid="9029649339816197345">"Možete se prebaciti na mobilnu mrežu kad god je Wi‑Fi veza loša. Mogu nastati troškovi prijenosa podataka."</string>
    <string name="lost_internet_access_switch" msgid="2262459569601190039">"Prebaci na mobilnu mrežu"</string>
    <string name="lost_internet_access_cancel" msgid="338273139419871110">"Ostani na WiFi mreži"</string>
    <string name="lost_internet_access_persist" msgid="7634876061262676255">"Nemoj više prikazivati"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Poveži se"</string>
    <string name="wifi_turned_on_message" msgid="4432839393213448846">"WiFi je uključen"</string>
    <!-- no translation found for wifi_connected_to_message (2265022072754345638) -->
    <skip />
    <string name="wifi_connecting" msgid="8760426806460651215">"Povezivanje…"</string>
    <!-- no translation found for wifi_disconnect (3445234285136039895) -->
    <skip />
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Povezivanje na mrežu nije uspjelo"</string>
    <string name="wifi_not_in_range_message" msgid="6616864204007424228">"Mreža nije u dometu"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Zaboravi"</string>
    <string name="wifi_modify" msgid="6100248070440710782">"Izmijeni"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Zaboravljanje mreže nije uspjelo"</string>
    <string name="wifi_save" msgid="3331121567988522826">"Sačuvaj"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Čuvanje mreže nije uspjelo"</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Otkaži"</string>
    <string name="wifi_forget_dialog_title" msgid="6224151903586192426">"Zaboraviti mrežu?"</string>
    <string name="wifi_forget_dialog_message" msgid="2337060138532166680">"Sve lozinke za ovu mrežu će se izbrisati"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="6094679048871529675">
      <item quantity="one">%d mreža</item>
      <item quantity="few">%d mreže</item>
      <item quantity="other">%d mreža</item>
    </plurals>
    <!-- no translation found for wifi_saved_passpoint_access_points_summary (8256430439661111672) -->
    <!-- no translation found for wifi_saved_all_access_points_summary (149386761654596280) -->
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Napredni WiFi"</string>
    <string name="wifi_advanced_ssid_title" msgid="1552309166043760291">"SSID"</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC adresa"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP adresa"</string>
    <string name="wifi_details_title" msgid="8954667664081737098">"Detalji o mreži"</string>
    <string name="wifi_details_subnet_mask" msgid="6720279144174924410">"Maska podmreže"</string>
    <string name="wifi_details_dns" msgid="8648826607751830768">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="6734119149106422148">"IPv6 adrese"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Sačuvane mreže"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="6480224551765489055">"Pretplate"</string>
    <!-- no translation found for wifi_saved_access_points_tab (2659675386657663705) -->
    <skip />
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"IP postavke"</string>
    <string name="wifi_advanced_not_available" msgid="5823045095444154586">"Napredne WiFi postavke nisu dostupne za ovog korisnika"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Sačuvaj"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Otkaži"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Unesite važeću IP adresu."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Unesite važeću adresu pristupnika."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Unesite važeću DNS adresu."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Unesite dužinu mrežnog prefiksa između 0 i 32."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Pristupnik"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Dužina prefiksa mreže"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"WiFi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Informacije o uređaju"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Zapamti ovu vezu"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Potraži uređaje"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Pretraživanje…"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Promijeni naziv uređaja"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Ravnopravni uređaji"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Zapamćene grupe"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8491862096448192157">"Povezivanje nije uspjelo."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Promjena naziva uređaja nije uspjela."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Prekinuti vezu?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Ako prekinete vezu, okončat će se veza s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Ako prekinete vezu, okončat će se veza s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g> i još <xliff:g id="PEER_COUNT">%2$s</xliff:g> uređaja."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Otkazati pozivnicu?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Da li želite otkazati pozivnicu za povezivanje s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Zaboraviti ovu grupu?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"WiFi pristupna tačka"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2199911382555864644">"Nema dijeljenja interneta ili sadržaja s drugim uređajima"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5936710887156133458">"Dijeljenje internetske veze ovog tableta putem pristupne tačke"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="default" msgid="5556202634866621632">"Dijeljenje internetske veze ovog telefona putem pristupne tačke"</string>
    <string name="wifi_hotspot_on_local_only_subtext" msgid="5017191966153008">"Aplikacija dijeli sadržaj. Za dijeljenje internetske veze isključite pa uključite pristupnu tačku"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="353306131026431089">"Lozinka nije postavljena"</string>
    <string name="wifi_hotspot_name_title" msgid="8237000746618636778">"Naziv pristupne tačke"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="3378299995508671967">"Uključivanje pristupne tačke <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>…"</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="3888672084861445362">"Drugi uređaji se mogu povezati na pristupnu tačku <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_hotspot_password_title" msgid="8676859981917573801">"Lozinka pristupne tačke"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="1165801173359290681">"AP opseg"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="4789553667374849566">"Koristite pristupnu tačku da kreirate Wi‑Fi mrežu za ostale svoje uređaje. Pristupna tačka pruža internet koristeći vašu vezu za prijenos podataka na mobilnoj mreži. Mogu nastati dodatni troškovi prijenosa mobilnih podataka."</string>
    <string name="wifi_hotspot_footer_info_local_only" msgid="857988412470694109">"Aplikacije mogu kreirati pristupnu tačku za dijeljenje sadržaja s uređajima u blizini."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="1590313508558948079">"Automatski isključi pristupnu tačku"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="5858098059725925084">"WiFi pristupna tačka će se isključiti ako nijedan uređaj nije povezan"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Uključivanje pristupne tačke…"</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Isključivanje pristupne tačke…"</string>
    <string name="wifi_tether_enabled_subtext" msgid="7842111748046063857">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktivna"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Greška kod prijenosne WiFi pristupne tačke"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Postavljanje WiFi pristupne tačke"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Postavke WiFi pristupne tačke"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5560680057727007011">"AndroidAP WPA2 PSK pristupna tačka"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"Android pristupna tačka"</string>
    <string name="wifi_calling_settings_title" msgid="4102921303993404577">"Pozivanje putem WiFi-ja"</string>
    <string name="wifi_calling_suggestion_title" msgid="5702964371483390024">"Proširite mogućnost pozivanja s Wi‑Fi-jem"</string>
    <string name="wifi_calling_suggestion_summary" msgid="1331793267608673739">"Uključite pozivanje putem Wi‑Fi-ja za veću pokrivenost"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Postavka poziva"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="7105195222267749226">"Postavka pozivanja"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="1565039047187685115">"Postavke rominga"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (8642014873060687717) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="7800926602662078576">"Postavke rominga"</string>
  <string-array name="wifi_calling_mode_choices">
    <item msgid="772621647207148279">"@*android:string/wfc_mode_wifi_preferred_summary"</item>
    <item msgid="2226422868199612072">"@*android:string/wfc_mode_cellular_preferred_summary"</item>
    <item msgid="7041954411163832397">"@*android:string/wfc_mode_wifi_only_summary"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="742988808283756263">"WiFi"</item>
    <item msgid="7715869266611010880">"Mobilna mreža"</item>
    <item msgid="2838022395783120596">"Samo WiFi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_without_wifi_only">
    <item msgid="4430473354160964286">"@*android:string/wfc_mode_wifi_preferred_summary"</item>
    <item msgid="5965810717958113109">"@*android:string/wfc_mode_cellular_preferred_summary"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="6132150507201243768">"WiFi"</item>
    <item msgid="1118703915148755405">"Mobilna mreža"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="9092988115148569860">"Ako WiFi nije dostupan, koristi mobilnu mrežu"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="240885549023046403">"Ako mobilna mreža nije dostupna, koristi WiFi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3688265826855460036">"Pozivanje putem WiFi-ja. Ako se izgubi WiFi, poziv će se prekinuti."</string>
    <string name="wifi_calling_off_explanation" msgid="564780186974911501">"Kada je opcija Pozivanje putem WiFi-ja uključena, telefon može preusmjeravati pozive putem WiFi mreža ili mreže vašeg operatera, u zavisnosti od toga kakve su vaše postavke i koji signal je jači. Prije nego što uključite ovu funkciju, raspitajte se o naknadi i drugim informacijama kod operatera.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="2329334487851497223"></string>
    <string name="emergency_address_title" msgid="932729250447887545">"Adresa za hitne slučajeve"</string>
    <string name="emergency_address_summary" msgid="7751971156196115129">"Koristi se kao vaša lokacija prilikom hitnog poziva putem Wi‑Fi mreže"</string>
    <string name="private_dns_help_message" msgid="3299567069152568958"><annotation id="url">"Saznajte više"</annotation>" o funkcijama Privatnog DNS-a"</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="6845711858866828986">"Postavkom upravlja mobilni operater"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="7492509632478260955">"Aktivirajte pozivanje putem WiFi-ja"</string>
    <string name="wifi_calling_turn_on" msgid="1171403510313983983">"Uključite pozivanje putem WiFi-ja"</string>
    <string name="wifi_calling_not_supported" msgid="7878640438907807754">"Pozivanje putem WiFi-ja nije podržano za mobilnog operatera %1$s"</string>
    <string name="carrier" msgid="5264014738689761132">"Mobilni operater"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Prikaz"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Zvuk"</string>
    <string name="all_volume_title" msgid="4296957391257836961">"Jačine zvuka"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Muzički efekti"</string>
    <string name="ring_volume_title" msgid="5592466070832128777">"Jačina zvuka zvona"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibriraj u nečujnom načinu rada"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Zadani zvuk obavještenja"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Melodija zvona"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Obavještenje"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Koristi jačinu zvuka dolaznih poziva za obavještenja"</string>
    <string name="home_work_profile_not_supported" msgid="1357721012342357037">"Ne podržava radne profile"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Zadani zvuk obavještenja"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Mediji"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Postavi jačinu zvuka za muziku i video zapise"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Alarm"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Postavke zvuka za priloženu priključnu stanicu"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Tonovi prilikom dodirivanja tastature telefona"</string>
    <string name="sound_effects_enable_title" msgid="4429690369187229592">"Zvukovi dodira"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Zvuk zaključavanja ekrana"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Poništavanje buke"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Muzika, video, igre i drugi medijski sadržaji"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Melodija zvona i obavještenja"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Obavještenja"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmi"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Isključi zvuk melodije zvona i obavještenja"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Isključi zvuk za muziku i druge medijske sadržaje"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Isključi zvuk obavještenja"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Isključi zvuk alarma"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Priključna stanica"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Postavke priključne stanice"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Zvuk"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Postavke za priloženu priključnu stanicu za radni sto"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Postavke za prikačeni mobilni držač za auto"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tablet nije u priključnoj stanici"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefon nije u priključnoj stanici"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Postavke za priloženu priključnu stanicu"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Priključna stanica nije pronađena"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Trebate staviti tablet u priključnu stanicu prije postavljanja zvuka za priključnu stanicu."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Trebate staviti telefon u priključnu stanicu prije postavljanja zvuka za priključnu stanicu."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Zvuk prilikom umetanja u priključnu stanicu"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Reproduciraj zvuk prilikom stavljanja ili vađenja tableta iz priključne stanice"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Reproduciraj zvuk prilikom stavljanja ili vađenja telefona iz priključne stanice"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="4308252722466813560">"Zvuk se ne reprodukuje prilikom uključivanja tableta u priključnu stanicu ili njegovog isključivanja iz nje"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="2034927992716667672">"Zvuk se ne reprodukuje prilikom uključivanja telefona u priključnu stanicu ili njegovog isključivanja iz nje"</string>
    <string name="account_settings" msgid="6403589284618783461">"Računi"</string>
    <string name="accessibility_category_work" msgid="4339262969083355720">"Računi radnog profila – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="1263518850905945594">"Računi ličnog profila"</string>
    <string name="accessibility_work_account_title" msgid="1231830766637939527">"Račun za Work – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="2169071663029067826">"Lični račun – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="1910951467596035063">"Pretraži"</string>
    <string name="display_settings" msgid="7965901687241669598">"Ekran"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Automatsko rotiranje ekrana"</string>
    <string name="color_mode_title" msgid="9186249332902370471">"Boje"</string>
    <string name="color_mode_option_natural" msgid="5013837483986772758">"Prirodne"</string>
    <string name="color_mode_option_boosted" msgid="8588223970257287524">"Pojačane"</string>
    <string name="color_mode_option_saturated" msgid="4569683960058798843">"Zasićene"</string>
    <string name="color_mode_option_automatic" msgid="7996505473528529568">"Prilagodljivi način"</string>
    <string name="color_mode_summary_natural" msgid="6624188642920403099">"Koristi samo precizne boje"</string>
    <string name="color_mode_summary_automatic" msgid="4669516973360709431">"Prilagodite između izraženih i preciznih boja"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Automatski promijeni orijentaciju prilikom rotiranja tableta"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Automatski promijeni orijentaciju prilikom rotiranja telefona"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Automatski promijeni orijentaciju prilikom rotiranja tableta"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Automatski promijeni orijentaciju prilikom rotiranja telefona"</string>
    <string name="brightness" msgid="8480105032417444275">"Nivo osvjetljenja"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Osvjetljenje"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Prilagodite osvjetljenje ekrana"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Prilagodljiva osvijetljenost"</string>
    <string name="auto_brightness_summary_on" msgid="3519854265558828744">"Uključeno"</string>
    <string name="auto_brightness_summary_off" msgid="2802336459335410626">"Isključeno"</string>
    <string name="auto_brightness_summary_very_low" msgid="6483976609035853764">"Preferirani nivo osvjetljenja je veoma nizak"</string>
    <string name="auto_brightness_summary_low" msgid="5609877905833960427">"Preferirani nivo osvjetljenja je nizak"</string>
    <string name="auto_brightness_summary_default" msgid="7225666614394726845">"Preferirani nivo osvjetljenja je zadani"</string>
    <string name="auto_brightness_summary_high" msgid="7172304165631136027">"Preferirani nivo osvjetljenja je visok"</string>
    <string name="auto_brightness_summary_very_high" msgid="979277812582279078">"Preferirani nivo osvjetljenja je veoma visok"</string>
    <string name="auto_brightness_off_title" msgid="2996864829946190795">"Isključeno"</string>
    <string name="auto_brightness_very_low_title" msgid="8252988638614126320">"Veoma nizak"</string>
    <string name="auto_brightness_low_title" msgid="1632186441514863377">"Nizak"</string>
    <string name="auto_brightness_default_title" msgid="936771997353506620">"Zadano"</string>
    <string name="auto_brightness_high_title" msgid="2527853305981497345">"Visok"</string>
    <string name="auto_brightness_very_high_title" msgid="8867164854439331022">"Veoma visok"</string>
    <string name="auto_brightness_subtitle" msgid="6454652530864093466">"Vaš preferirani nivo osvjetljenja"</string>
    <string name="auto_brightness_off_summary" msgid="7629228736838155268">"Ne podešavaj prema dostupnom svjetlu"</string>
    <string name="auto_brightness_very_high_summary" msgid="4551003097086220709">"Povećana potrošnja baterije"</string>
    <string name="auto_brightness_disclaimer" msgid="871436423746343406">"Optimizirajte nivo osvjetljenja prema dostupnom svjetlu. Kada je ova funkcija uključena i dalje možete privremeno podešavati nivo osvjetljenja."</string>
    <string name="auto_brightness_description" msgid="7310335517128283729">"Osvijetljenost ekrana će se automatski prilagođavati vašem okruženju i aktivnostima. Klizač možete ručno pomjerati kako bi prilagodljiva osvijetljenost zapamtila vaše postavke."</string>
    <string name="display_white_balance_title" msgid="4093966473741329340">"Balans bijele boje prikaza"</string>
    <string name="adaptive_sleep_title" msgid="455088457232472047">"Svjesni ekran"</string>
    <string name="adaptive_sleep_summary_on" msgid="410222811715459549">"Uključeno/Ekran se neće isključiti ako gledate u njega"</string>
    <string name="adaptive_sleep_summary_off" msgid="3099674463517017514">"Isključeno"</string>
    <string name="adaptive_sleep_description" msgid="3202004081780217465">"Sprječava isključivanje ekrana ako gledate u njega."</string>
    <string name="adaptive_sleep_privacy" msgid="5335695648960686765">"Funkcija Svjesni ekran koristi prednju kameru da utvrdi gleda li neko u ekran. Funkcionira na uređaju, a slike se nikada ne arhiviraju niti šalju Googleu."</string>
    <string name="night_display_title" msgid="2626451512200357686">"Noćno svjetlo"</string>
    <string name="night_display_text" msgid="1837277457033025056">"Noćno svjetlo oboji ekran u žutosmeđe. Tako je lakše gledati u ekran ili čitati pod prigušenim svjetlom, a može vam pomoći da lakše zaspite."</string>
    <string name="night_display_auto_mode_title" msgid="6574111412154833409">"Raspored"</string>
    <string name="night_display_auto_mode_never" msgid="2483761922928753400">"Ništa"</string>
    <string name="night_display_auto_mode_custom" msgid="2379394568898721765">"Uključuje se u zadano vrijeme"</string>
    <string name="night_display_auto_mode_twilight" msgid="589042813708244059">"Uključeno od sumraka do svitanja"</string>
    <string name="night_display_start_time_title" msgid="8918016772613689584">"Vrijeme početka"</string>
    <string name="night_display_end_time_title" msgid="8286061578083519350">"Vrijeme završetka"</string>
    <string name="night_display_status_title" msgid="1784041143360286267">"Status"</string>
    <string name="night_display_temperature_title" msgid="1435292789272017136">"Intenzitet"</string>
    <string name="night_display_summary_off" msgid="1792750041697946539">"Isključeno / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="3583590137322963513">"Neće se nikada automatski uključiti"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6365668239253173208">"Automatski će se uključiti u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3596291693781757392">"Automatski će se uključiti u sumrak"</string>
    <string name="night_display_summary_on" msgid="1355713529996456744">"Uključeno / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="9117830821363119835">"Neće se nikada automatski isključiti"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="5510753572245577263">"Automatski će se isključiti u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="852270120144683507">"Automatski će se isključiti u svitanje"</string>
    <string name="night_display_activation_on_manual" msgid="277343561277625826">"Uključi sada"</string>
    <string name="night_display_activation_off_manual" msgid="4074557720918572883">"Isključi sada"</string>
    <string name="night_display_activation_on_twilight" msgid="6976051971534953845">"Uključi do izlaska sunca"</string>
    <string name="night_display_activation_off_twilight" msgid="7196227685059907233">"Isključi do zalaska sunca"</string>
    <string name="night_display_activation_on_custom" msgid="5472029024427933598">"Uključi do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="6169984658293744715">"Isključi do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_not_currently_on" msgid="6273540991113206401">"Noćno svjetlo nije uključeno"</string>
    <string name="screen_timeout" msgid="4882669461447531301">"Privremeni prekid rada zaslona"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"Ekran se isključuje"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Nakon <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neaktivnosti"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Pozadinska slika"</string>
    <string name="style_and_wallpaper_settings_title" msgid="3608097576881470764">"Stilovi i pozadinske slike"</string>
    <string name="wallpaper_settings_summary_default" msgid="3395741565658711416">"Zadano"</string>
    <string name="wallpaper_settings_summary_custom" msgid="515035303981687172">"Prilagođeno"</string>
    <string name="wallpaper_suggestion_title" msgid="8583988696513822528">"Promijenite pozadinsku sliku"</string>
    <string name="wallpaper_suggestion_summary" msgid="1579144009898110491">"Prilagodite svoj ekran"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Odabir pozadinske slike iz"</string>
    <string name="screensaver_settings_title" msgid="1770575686476851778">"Čuvar ekrana"</string>
    <string name="screensaver_settings_summary_either_long" msgid="7302740999250873332">"Tokom punjenja ili kada je na priključnoj stanici"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"Bilo koje"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Tokom punjenja"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Kada je na priključnoj stanici"</string>
    <string name="screensaver_settings_summary_never" msgid="5165622985174349585">"Nikada"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Isključeno"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1239088321034437608">"Za kontrolisanje dešavanja kada je telefon priključen i/ili dok miruje, uključi čuvara ekrana."</string>
    <string name="screensaver_settings_when_to_dream" msgid="7262410541382890146">"Kada početi"</string>
    <string name="screensaver_settings_current" msgid="4663846038247130023">"Trenutni čuvar ekrana"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Započni odmah"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Postavke"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Automatsko osvjetljenje"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Podignite za buđenje"</string>
    <string name="ambient_display_screen_title" msgid="4252755516328775766">"Ambijentalni prikaz"</string>
    <string name="ambient_display_category_triggers" msgid="4359289754456268573">"Kada prikazati"</string>
    <string name="doze_title" msgid="2375510714460456687">"Nova obavještenja"</string>
    <string name="doze_summary" msgid="3846219936142814032">"Ekran se aktivira kada primite obavještenja"</string>
    <string name="doze_always_on_title" msgid="1046222370442629646">"Uvijek uključeno"</string>
    <string name="doze_always_on_summary" msgid="6978257596231155345">"Prikaz vremena, ikona obavještenja i drugih informacija. Veća potrošnja baterije."</string>
    <string name="title_font_size" msgid="4405544325522105222">"Veličina fonta"</string>
    <string name="short_summary_font_size" msgid="6819778801232989076">"Povećavanje ili umanjivanje teksta"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Postavke zaključavanja SIM kartice"</string>
    <string name="sim_lock_settings_category" msgid="6242052161214271091">"Zaključavanje SIM kartice"</string>
    <string name="sim_lock_settings_summary_off" msgid="8028944267104896401">"Isključeno"</string>
    <string name="sim_lock_settings_summary_on" msgid="39103355956342985">"Zaključano"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Zaključavanje SIM kartice"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Zaključaj SIM karticu"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Zahtijevaj PIN za korištenje tableta"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Potreban je PIN za korištenje telefona"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Zahtijevaj PIN za korištenje tableta"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Potreban je PIN za korištenje telefona"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Promjena PIN-a SIM kartice"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"PIN za SIM"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Zaključavanje SIM kartice"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Otključaj SIM karticu"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Stari PIN za SIM"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Novi PIN za SIM"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Ponovo unesite novi PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"PIN za SIM"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Pogrešan PIN"</string>
    <string name="sim_pins_dont_match" msgid="1695021563878890574">"PIN-ovi se ne podudaraju"</string>
    <string name="sim_change_failed" msgid="3602072380172511475">"Nije moguće promijeniti PIN.\nMožda je PIN neispravan."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"PIN za SIM uspješno promijenjen"</string>
    <string name="sim_lock_failed" msgid="2489611099235575984">"Ne možete otključati SIM.\nPIN je možda pogrešan."</string>
    <string name="sim_pin_disable_failed" msgid="7932981135799678220">"Onemogućavanje PIN-a nije uspelo."</string>
    <string name="sim_pin_enable_failed" msgid="3414621075632931753">"Omogućavanje PIN-a nije uspelo."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"Uredu"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Otkaži"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"Pronađeno više SIM-ova"</string>
    <string name="sim_multi_sims_summary" msgid="2698176447067691396">"Odaberite željenu SIM karticu za prijenos podataka na mobilnoj mreži."</string>
    <string name="sim_change_data_title" msgid="5045967581557404143">"Koristiti <xliff:g id="CARRIER">%1$s</xliff:g> za mobilne podatke?"</string>
    <string name="sim_change_data_message" msgid="4307243848083368600">"Koristite <xliff:g id="CARRIER2_0">%2$s</xliff:g> za prijenos podataka na mobilnoj mreži. Ako se prebacite na operatera <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> se više neće koristiti za prijenos podataka na mobilnoj mreži."</string>
    <string name="sim_change_data_ok" msgid="7929746101841679535">"Koristi <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="5567909634636045268">"Ažurirati željenu SIM karticu?"</string>
    <string name="sim_preferred_message" msgid="8466930554330635780">"SIM kartica <xliff:g id="NEW_SIM">%1$s</xliff:g> jedina je SIM kartica u vašem uređaju. Želite li tu SIM karticu koristiti za prijenos podataka na mobilnoj mreži, pozive i SMS poruke?"</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"PIN za SIM je netačan. Za otključavanje uređaja sada morate kontaktirati svog operatera."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="1582398808893048097">
      <item quantity="one">PIN za SIM je netačan. Preostao vam je još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaj.</item>
      <item quantity="few">PIN za SIM je netačan. Preostala su vam još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaja.</item>
      <item quantity="other">PIN za SIM je netačan. Preostalo vam je još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaja.</item>
    </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Operacija PIN-a za SIM nije uspjela!"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Ažuriranja sistema"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Verzija Androida"</string>
    <string name="security_patch" msgid="8438384045870296634">"Nivo sigurnosne zakrpe Androida"</string>
    <string name="model_info" msgid="1952009518045740889">"Model"</string>
    <string name="model_summary" msgid="8306235877567782987">"Model: %1$s"</string>
    <string name="hardware_info" msgid="2605080746512527805">"Model i hardver"</string>
    <string name="hardware_revision" msgid="8893547686367095527">"Verzija hardvera"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"ID opreme"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Verzija nemoduliranog opsega"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Verzija jezgre"</string>
    <string name="build_number" msgid="3075795840572241758">"Broj verzije"</string>
    <string name="module_version" msgid="4826567303427436423">"Verzije glavnog modula"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Nije dostupno"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Status"</string>
    <string name="device_status" msgid="607405385799807324">"Status"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Status baterije, mreže i druge informacije"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Broj telefona, signal itd."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Pohrana"</string>
    <string name="storage_settings_for_app" msgid="1922207623125501014">"Pohrana i keš memorija"</string>
    <string name="storage_usb_settings" msgid="7293054033137078060">"Memorija"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Postavke za pohranu"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Deaktiviraj USB pohranu, prikaži dostupnu pohranu"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Deaktiviraj SD karticu, prikaži dostupnu pohranu"</string>
    <string name="imei_multi_sim" msgid="6387012961838800539">"IMEI (utor za sim %1$d)"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5948892105546651296">"Telefonski broj"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="2755592991367858860">"MDN (utor za sim %1$d)"</string>
    <string name="status_number_sim_slot" product="default" msgid="1898212200138025729">"Broj telefona (utor za sim %1$d)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="1367110147304523864">"MDN na SIM-u"</string>
    <string name="status_number_sim_status" product="default" msgid="9123351360569466330">"Broj telefona na SIM-u"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MIN"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"Verzija PRL-a"</string>
    <string name="meid_multi_sim" msgid="748999971744491771">"MEID (utor za sim %1$d)"</string>
    <string name="scanning_status_text_wifi_on_ble_on" msgid="5262263689045962681">"Uključeno je i WiFi i Bluetooth skeniranje"</string>
    <string name="scanning_status_text_wifi_on_ble_off" msgid="2115399719199757550">"Uključeno je WiFi skeniranje, isključeno je Bluetooth skeniranje"</string>
    <string name="scanning_status_text_wifi_off_ble_on" msgid="3212656150021004088">"Uključeno je Bluetooth skeniranje, isključeno je WiFi skeniranje"</string>
    <string name="scanning_status_text_wifi_off_ble_off" msgid="6381094990708345188">"Isključeno je i Wifi i Bluetooth skeniranje"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_data_network_type" msgid="7570837037428932780">"Vrsta mobilne mreže podataka"</string>
    <string name="status_voice_network_type" msgid="5663112239742353547">"Tip mobilne glasovne mreže"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Informacije o operateru"</string>
    <string name="status_data_state" msgid="5503181397066522950">"Stanje mobilne mreže"</string>
    <string name="status_esim_id" msgid="6456255368300906317">"EID"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Stanje usluge"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Jačina signala"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Roming"</string>
    <string name="status_operator" msgid="2274875196954742087">"Mreža"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"MAC adresa WiFi mreže"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Bluetooth adresa"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Serijski broj"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Vrijeme aktivnosti"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Vrijeme aktivnosti"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Interna pohrana"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"USB pohrana"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"SD kartica"</string>
    <string name="memory_available" msgid="5052397223077021181">"Dostupno"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"Dostupno (samo za čitanje)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Ukupni prostor"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Računanje…"</string>
    <string name="memory_apps_usage" msgid="5128673488173839077">"Aplikacije i podaci aplikacija"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Mediji"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Preuzimanja"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Slike, videozapisi"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Zvuk (muzika, melodije zvona, podcasti itd.)"</string>
    <string name="memory_media_misc_usage" msgid="6094866738586451683">"Drugi fajlovi"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Keširani podaci"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Deaktiviraj dijeljenu pohranu"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Deaktiviraj SD karticu"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Deaktiviraj internu USB pohranu"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Demontirajte SD karticu kako biste je mogli bezbjedno ukloniti"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Umetnite USB pohranu za aktiviranje"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Umetnite SD karticu za aktiviranje"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Aktivirajte USB pohranu"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Aktivirajte SD karticu"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Izbriši USB pohranu"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Izbriši SD karticu"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Briše sve podatke na internoj USB pohrani, kao što su muzika i fotografije"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Briše sve podatke na SD kartici, kao što su muzika i fotografije"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Želite li zbrisati keširane podatke?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Ovo briše keširane podatke za sve aplikacije."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"Funkcija MTP ili PTP je aktivna"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Deaktivirati USB pohranu?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Deaktivirati SD karticu?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Ako deaktivirate USB pohranu, neke aplikacije koje koristite će prestati raditi i može se desiti da budu nedostupne dok ponovo ne aktivirate USB pohranu."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Ako deaktivirate SD karticu, neke aplikacije koje koristite će prestati raditi i može se desiti da budu nedostupne dok ponovo ne aktivirate SD karticu."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="9191518889746166147">"USB memorija se ne može isključiti. Pokušajte ponovo kasnije."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3500976899159848422">"Nije bilo moguće odvojiti SD karticu. Pokušajte ponovo kasnije."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"USB pohrana će biti deaktivirana."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"SD kartica će biti deaktivirana."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Deaktiviranje"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Deaktiviranje u toku"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Prostor za pohranu ponestaje"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Neke funkcije sistema, kao što je sinhronizacija, možda neće raditi ispravno. Pokušajte osloboditi prostor brisanjem ili deaktiviranjem stavki kao što su aplikacije ili medijski sadržaj."</string>
    <string name="storage_menu_rename" msgid="7141058657592615390">"Promijeni naziv"</string>
    <string name="storage_menu_mount" msgid="1014683672493425425">"Montiraj"</string>
    <string name="storage_menu_unmount" msgid="681485356885955898">"Izbaci"</string>
    <string name="storage_menu_format" msgid="7690626079653152152">"Formatiraj"</string>
    <string name="storage_menu_format_public" msgid="7464714208010125682">"Formatiraj kao prenosivu"</string>
    <string name="storage_menu_format_private" msgid="546017531835902096">"Formatiraj kao unutrašnju"</string>
    <string name="storage_menu_migrate" msgid="3969621494238154294">"Prenesi podatke"</string>
    <string name="storage_menu_forget" msgid="6305824238997983426">"Zaboraviti"</string>
    <string name="storage_menu_set_up" msgid="4263294929451685366">"Postavi"</string>
    <string name="storage_menu_explore" msgid="4637496051816521560">"Istraži"</string>
    <string name="storage_menu_free" msgid="6386070442027135427">"Oslobodi prostor"</string>
    <string name="storage_menu_manage" msgid="5914482953856430780">"Upravljaj prostorom za pohranu"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Veza s računarom preko USB-a"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Poveži kao"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Medijski uređaj (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Omogućava prenošenje medijskih fajlova u Windows ili korištenje Android File Transfer aplikacije za Mac (pogledajte www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Kamera (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7406889433172511530">"Omogućava vam da prenesete fotografije pomoću softvera fotoaparata i da prenesete sve fajlove na računare koji ne podržavaju MTP"</string>
    <string name="usb_midi_title" msgid="3069990264258413994">"MIDI"</string>
    <string name="usb_midi_summary" msgid="539169474810956358">"Omogućava da MIDI omogućene aplikacije rade preko USB-a sa MIDI softverom na vašem računaru."</string>
    <string name="storage_other_users" msgid="808708845102611856">"Drugi korisnici"</string>
    <string name="storage_internal_title" msgid="690771193137801021">"Uređaj za memoriju"</string>
    <string name="storage_external_title" msgid="3433462910096848696">"Prenosiva memorija"</string>
    <string name="storage_volume_summary" msgid="7023441974367853372">"<xliff:g id="USED">%1$s</xliff:g> se koristi od <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="storage_size_large" msgid="5691585991420946254">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>"<xliff:g id="UNIT">^2</xliff:g>"</small></small></string>
    <string name="storage_volume_used" msgid="1303803057698959872">"Se koristi od <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_volume_used_total" msgid="6113121714019000244">"Ukupno iskorišteno od <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_mount_success" msgid="687641090137253647">"<xliff:g id="NAME">%1$s</xliff:g> je priključen"</string>
    <string name="storage_mount_failure" msgid="1042621107954547316">"Nije se mogao montirati <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="5737203344673441677">"Uređaj <xliff:g id="NAME">%1$s</xliff:g> je sigurno izbačen"</string>
    <string name="storage_unmount_failure" msgid="5758387106579519489">"<xliff:g id="NAME">%1$s</xliff:g> se ne može sigurno izbaciti"</string>
    <string name="storage_format_success" msgid="3023144070597190555">"Uređaj <xliff:g id="NAME">%1$s</xliff:g> je formatiran"</string>
    <string name="storage_format_failure" msgid="6032640952779735766">"Ne može se formatirati <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_rename_title" msgid="8242663969839491485">"Promjena naziva pohrane"</string>
    <string name="storage_dialog_unmounted" msgid="6403320870103261477">"Ovaj uređaj (<xliff:g id="NAME_0">^1</xliff:g>) je uspješno uklonjen, ali je i dalje dostupan. \n\nDa biste koristili uređaj <xliff:g id="NAME_1">^1</xliff:g>, prvo ga morate priključiti."</string>
    <string name="storage_dialog_unmountable" msgid="3732209361668282254">"Ovaj <xliff:g id="NAME_0">^1</xliff:g> je oštećen. \n\nDa biste koristili ovaj <xliff:g id="NAME_1">^1</xliff:g>, najprije ga morate postaviti."</string>
    <string name="storage_dialog_unsupported" msgid="4503128224360482228">"Ovaj uređaj ne podržava <xliff:g id="NAME_0">^1</xliff:g>. \n\n Da biste koristili <xliff:g id="NAME_1">^1</xliff:g> s ovim uređajem, najprije ga morate postaviti."</string>
    <string name="storage_internal_format_details" msgid="4018647158382548820">"Nakon formatiranja, možete koristiti ovu <xliff:g id="NAME_0">^1</xliff:g> u drugim uređajima. \n\n Svi podaci sa ove <xliff:g id="NAME_1">^1</xliff:g> će biti izbrisani. Razmislite prvo o kreiranju sigurnosne kopije \n\n"<b>" Rezervne kopije za Fotografije i druge medije "</b>\n" Premjestite multimedijalne fajlove u alternativne skladištenje na ovom uređaju, ili ih prenesete na računalo pomoću USB kabla. \n\n"<b>" Sigurnosne kopije za aplikacije"</b>\n" Sve aplikacije pohranjene na ovom <xliff:g id="NAME_6">^1</xliff:g> će biti deinstalirane i njihovi podaci će biti izbrisani. Da bi ove aplikacije sačuvali, premjestite ih u alternativne memorije na ovom uređaju."</string>
    <string name="storage_internal_unmount_details" msgid="3582802571684490057"><b>"Kada izbacite ovaj uređaj (<xliff:g id="NAME_0">^1</xliff:g>), aplikacije pohranjene na njemu će prestati radit, a medijski fajlovi pohranjeni na njemu neće biti dostupni dok ga ponovo ne umetnete."</b>" \n\nUređaj <xliff:g id="NAME_1">^1</xliff:g> je formatiran tako da funkcionira samo na ovom uređaju. Neće funkcionirati na bilo kojem drugom uređaju."</string>
    <string name="storage_internal_forget_details" msgid="9028875424669047327">"Da biste koristili aplikacije, slike ili podatke koje ovaj uređaj (<xliff:g id="NAME">^1</xliff:g>) sadrži, ponovo ga umetnite. \n\nUmjesto toga, možete odabrati da zaboravite ovu memoriju ukoliko uređaj nije dostupan \n\nAko odaberete da zaboravite memoriju, svi podaci koje uređaj sadrži će zauvijek biti izgubljeni \n\nAplikacije možete kasnije ponovo instalirati, ali njihovi podaci pohranjeni na ovom uređaju će biti izgubljeni."</string>
    <string name="storage_internal_forget_confirm_title" msgid="1370847944388479245">"Želite li zaboraviti uređaj <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="1148446041396902905">"Sve aplikacije, fotografije i podaci pohranjeni na ovom <xliff:g id="NAME">^1</xliff:g> bit će trajno izgubljeni."</string>
    <string name="storage_detail_apps" msgid="6141154016753507490">"Aplikacije"</string>
    <string name="storage_detail_images" msgid="6950678857740634769">"Slike"</string>
    <string name="storage_detail_videos" msgid="2919743464827110953">"Video zapisi"</string>
    <string name="storage_detail_audio" msgid="1197685141676483213">"Zvuk"</string>
    <string name="storage_detail_cached" msgid="8547136365247818567">"Keširani podaci"</string>
    <string name="storage_detail_other" msgid="8404938385075638238">"Ostalo"</string>
    <string name="storage_detail_system" msgid="4629506366064709687">"Sistem"</string>
    <string name="storage_detail_explore" msgid="7911344011431568294">"Istraži korisnika <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_detail_dialog_other" msgid="8845766044697204852">"Ostalo uključuje dijeljene fajlove koji su sačuvani pomoću aplikacija, fajlove koji su preuzeti s interneta ili Bluetootha, fajlove za Android uređaje i tako dalje. \n\nDa vidite vidljivi sadržaj ovog uređaja, <xliff:g id="NAME">^1</xliff:g>, dodirnite Istraži."</string>
    <string name="storage_detail_dialog_system" msgid="862835644848361569">"Sistem obuhvata fajlove koji se koriste za pokretanje verzije Androida <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_detail_dialog_user" msgid="3267254783294197804">"Moguće je da je <xliff:g id="USER_0">^1</xliff:g> sačuvao/la fotografije, muziku, aplikacije ili druge podatke koristeći <xliff:g id="SIZE">^2</xliff:g> prostora za pohranu. \n\nDa vidite detalje, prebacite se na korisnika <xliff:g id="USER_1">^1</xliff:g>."</string>
    <string name="storage_wizard_init_title" msgid="5085400514028585772">"Podesite uređaj <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="4867326438945303598">"Koristiti kao prijenosnu memoriju"</string>
    <string name="storage_wizard_init_external_summary" msgid="7476105886344565074">"Za premještanje fotografija i drugih medija s jednog uređaja na drugi."</string>
    <string name="storage_wizard_init_internal_title" msgid="9100613534261408519">"Koristi kao unutrašnju memoriju"</string>
    <string name="storage_wizard_init_internal_summary" msgid="6240417501036216410">"Za memorisanje bilo čega samo na ovaj uređaj uključujući aplikacije i fotografije. Zahtijeva formatiranje koje sprečavaju da radi sa drugim uređajima."</string>
    <string name="storage_wizard_format_confirm_title" msgid="2814021794538252546">"Formatirajte kao unutr. memoriju"</string>
    <string name="storage_wizard_format_confirm_body" msgid="4401758710076806509">"To zahtijeva da <xliff:g id="NAME_0">^1</xliff:g> bude formatirana da bi bila sigurna.\n\nNakon formatiranja, ova <xliff:g id="NAME_1">^1</xliff:g> će raditi samo na ovom uređaju. \n\n"<b>"Formatiranje briše sve podatke koji se trenutno na njoj nalaze <xliff:g id="NAME_2">^1</xliff:g>."</b>" Da biste izbjegli gubljenje podataka, razmotrite kreiranje sigurnosne kopije."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="4905690038882041566">"Formatirajte kao pren. memoriju"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="1516932692920060272">"Ovo zahtijeva da se <xliff:g id="NAME_0">^1</xliff:g> formatira. \n\n"<b>"Formatiranjem se brišu svi podaci trenutno pohranjeni na uređaju <xliff:g id="NAME_1">^1</xliff:g>."</b>" Da ne biste izgubili podatke, razmislite o kreiranju sigurnosne kopije."</string>
    <string name="storage_wizard_format_confirm_next" msgid="2774557300531702572">"Izbriši i formatiraj"</string>
    <string name="storage_wizard_format_progress_title" msgid="6487352396450582292">"Formatiranje <xliff:g id="NAME">^1</xliff:g>..."</string>
    <string name="storage_wizard_format_progress_body" msgid="3983764797223576658">"Nemojte uklanjati pohranu <xliff:g id="NAME">^1</xliff:g> dok se formatira."</string>
    <string name="storage_wizard_migrate_title" msgid="1363078147938160407">"Premjestite pod. u novu memoriju"</string>
    <string name="storage_wizard_migrate_body" msgid="890751699549542345">"Možete premjestiti slike, fajlove i neke aplikacije na novi uređaj <xliff:g id="NAME">^1</xliff:g>. \n\nPremještanje traje otprilike <xliff:g id="TIME">^2</xliff:g> te će osloboditi <xliff:g id="SIZE">^3</xliff:g> unutrašnje memorije. Neke aplikacije neće funkcionirati dok je ovo u toku."</string>
    <string name="storage_wizard_migrate_now" msgid="4523444323744239143">"Premjesti sada"</string>
    <string name="storage_wizard_migrate_later" msgid="3173482328116026253">"Premjesti kasnije"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="8564833529613286965">"Premjesti podatke sada"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="4212060581792135962"><b>"Premještanje traje oko <xliff:g id="TIME">^1</xliff:g>. To će osloboditi <xliff:g id="SIZE">^2</xliff:g> na <xliff:g id="NAME">^3</xliff:g>."</b></string>
    <string name="storage_wizard_migrate_confirm_next" msgid="5509475628423823202">"Premjesti"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="1665479429044202868">"Podaci se premještaju..."</string>
    <string name="storage_wizard_migrate_details" msgid="3709728824651136227">"Za vrijeme premještanja: \n• Nemojte uklanjati uređaj <xliff:g id="NAME">^1</xliff:g>. \n• Neke aplikacije neće funkcionirati ispravno. \n• Uređaj treba biti napunjen."</string>
    <string name="storage_wizard_ready_title" msgid="6553867088682695655">"Uređaj <xliff:g id="NAME">^1</xliff:g> je spreman za korištenje"</string>
    <string name="storage_wizard_ready_external_body" msgid="2879508114260597474">"Uređaj <xliff:g id="NAME">^1</xliff:g> je spreman za korištenje sa slikama i drugim medijima."</string>
    <string name="storage_wizard_ready_internal_body" msgid="122532674037860197">"Novi uređaj (<xliff:g id="NAME">^1</xliff:g>) funkcionira. \n\nDa biste premjestili slike, fajlove i podatke aplikacija na ovaj uređaj, idite na Postavke &gt; Memorija."</string>
    <string name="storage_wizard_move_confirm_title" msgid="292782012677890250">"Premjesti <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="5176432115206478941">"Premještanje <xliff:g id="APP">^1</xliff:g> i njenih podataka na <xliff:g id="NAME_0">^2</xliff:g> će trajati samo nekoliko trenutaka. Nećete biti u mogućnosti koristiti aplikacije sve dok se ne završi premještanje. \n\n Nemojte uklanjati <xliff:g id="NAME_1">^2</xliff:g> tokom premještanja."</string>
    <string name="storage_wizard_move_unlock" msgid="1526216561023200694">"Da prebacite podatke, morate otključati korisnika <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="4443920302548035674">"Premješta se <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="7802577486578105609">"Nemojte uklanjati <xliff:g id="NAME">^1</xliff:g> tokom premještanja. Aplikacija \n\n <xliff:g id="APP">^2</xliff:g> na ovom uređaju neće biti dostupna sve dok se ne završi premještanje."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="542047237524588792">"Poništi premještanje"</string>
    <string name="storage_wizard_slow_body" msgid="8010127667184768025">"Čini se da je <xliff:g id="NAME_0">^1</xliff:g> spora. \n\n Možete nastaviti, ali aplikacije koje su premještene na ovu lokaciju mogu zastajkivati te prijenos podataka može dugo trajati. \n\n Razmislite o korištenju brže<xliff:g id="NAME_1">^1</xliff:g> za bolje performanse."</string>
    <string name="storage_wizard_init_v2_title" msgid="8858395869710288372">"Kako ćete koristiti pohranu <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="4315585580670552654">"Koristi kao dodatnu pohranu na tabletu"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="570443086512059390">"Samo za aplikacije, fajlove i medije na ovom tabletu"</string>
    <string name="storage_wizard_init_v2_internal_action" product="tablet" msgid="7760758592993284143">"Pohrana na tabletu"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="8373070138732653456">"Koristi kao dodatnu pohranu na telefonu"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="685194340141573218">"Samo za aplikacije, fajlove i medije na ovom telefonu"</string>
    <string name="storage_wizard_init_v2_internal_action" product="default" msgid="904425171564310150">"Pohrana na telefonu"</string>
    <string name="storage_wizard_init_v2_or" msgid="1958295749349454436">"Ili"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="3565348221712759463">"Koristi kao prijenosnu pohranu"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="801198071793584445">"Za prenošenje fajlova i medija s jednog uređaja na drugi"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="8662451480642784031">"Prenosiva pohrana"</string>
    <string name="storage_wizard_init_v2_later" msgid="1080613420170749130">"Postavi kasnije"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="5744790239994621663">"Formatirati ovu pohranu <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="4614199613500900975">"Da biste pohranili aplikacije, fajlove i medije, potrebno je formatirati uređaj <xliff:g id="NAME_0">^1</xliff:g>. \n\nFormatiranjem se potpuno briše postojeći sadržaj pohrane <xliff:g id="NAME_1">^2</xliff:g>. Da ne biste izgubili sadržaj, napravite sigurnosnu kopiju na drugu pohranu <xliff:g id="NAME_2">^3</xliff:g> ili uređaj."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="8258363472135537500">"Format. pohranu <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="31406330052996898">"Premjestiti sadržaj na: <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4476553430145054781">"Fajlove, medije i određene aplikacije možete premjestiti na uređaj <xliff:g id="NAME">^1</xliff:g>. \n\nTime ćete osloboditi <xliff:g id="SIZE">^2</xliff:g> pohrane na tabletu što bi trebalo trajati oko <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_body" product="default" msgid="744760728669284385">"Fajlove, medije i određene aplikacije možete premjestiti na uređaj <xliff:g id="NAME">^1</xliff:g>. \n\nTime ćete osloboditi <xliff:g id="SIZE">^2</xliff:g> pohrane na telefonu što bi trebalo trajati oko <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="1239103359606165360">"Tokom premještanja:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="7176991995007075843">"Nemojte uklanjati pohranu <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="3671266712947078734">"Neke aplikacije neće raditi"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="346012901366624052">"Tablet treba biti napunjen"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="3061158350109289521">"Telefon treba biti napunjen"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="1279041707982039591">"Premjesti sadržaj"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="8201360307047198853">"Premjesti sadržaj kasnije"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="1323344099111423785">"Premještanje sadržaja…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="1318285829973607727">"Spora pohrana <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="6897444467730463117">"I dalje možete koristiti uređaj <xliff:g id="NAME_0">^1</xliff:g>, ali može biti spor. \n\nAplikacije pohranjene na pohrani <xliff:g id="NAME_1">^2</xliff:g> možda neće raditi ispravno, a prijenos sadržaja može dugo trajati. \n\nPokušajte koristiti bržu pohranu <xliff:g id="NAME_2">^3</xliff:g> ili koristite <xliff:g id="NAME_3">^4</xliff:g> kao prenosivu pohranu."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="4126873669723115805">"Počni ispočetka"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="49399942893518218">"Nastavi"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="11937346870534608">"Sadržaj možete premjestiti na pohranu <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="4658433206901211269">"Da premjestite sadržaj na pohranu <xliff:g id="NAME">^1</xliff:g>, idite u "<b>"Postavke &gt; Pohrana"</b></string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="6239886818487538806">"Sadržaj je premješten na pohranu <xliff:g id="NAME_0">^1</xliff:g>. \n\nDa upravljate ovom pohranom <xliff:g id="NAME_1">^2</xliff:g>, idite u "<b>"Postavke &gt; Pohrana"</b>"."</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Status baterije"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Nivo napunjenosti baterije"</string>
    <string name="apn_settings" msgid="3743170484827528406">"APN-ovi"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Uredi pristupnu tačku"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Nije postavljeno"</string>
    <string name="apn_name" msgid="4115580098369824123">"Ime"</string>
    <string name="apn_apn" msgid="2479425126733513353">"APN"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Proksi"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Priključak"</string>
    <string name="apn_user" msgid="455637547356117761">"Korisničko ime"</string>
    <string name="apn_password" msgid="5412301994998250968">"Lozinka"</string>
    <string name="apn_server" msgid="2436185314756372858">"Server"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"MMS proksi"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"MMS priključak"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Vrsta autentifikacije"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Ništa"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP ili CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Vrsta APN-a"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"APN protokol"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protokol za APN roming"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Omogući/onemogući APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"APN omogućen"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"APN onemogućen"</string>
    <string name="bearer" msgid="594270280031923558">"Nosilac"</string>
    <string name="mvno_type" msgid="2543253857818336421">"MVNO vrsta"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"MVNO vrijednost"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Izbriši APN"</string>
    <string name="menu_new" msgid="3014205883303921729">"Novi APN"</string>
    <string name="menu_save" msgid="8109345640668285399">"Sačuvaj"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Odbaci"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="5508155943840201232">"Polje Ime ne može ostati prazno."</string>
    <string name="error_apn_empty" msgid="4932211013600863642">"Naziv pristupne tačke ne može biti prazan."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"MCC polje mora imati 3 cifre."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"MNC polje mora imati 2 ili 3 cifre."</string>
    <string name="error_adding_apn_type" msgid="4181334016628549645">"Operater ne dozvoljava dodavanje APN-a tipa %s."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Vraćanje zadanih postavki za APN."</string>
    <string name="menu_restore" msgid="8260067415075573273">"Vrati na zadano"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Vraćanje zadanih postavki za APN dovršeno."</string>
    <string name="reset_dashboard_title" msgid="6254873816990678620">"Opcije vraćanja na zadano"</string>
    <string name="reset_dashboard_summary" msgid="4851012632493522755">"Mreža, aplikacije ili uređaj mogu se vratiti na zadano"</string>
    <string name="reset_network_title" msgid="6166025966016873843">"Vrati WiFi, mobilnu i Bluetooth vezu na zadano"</string>
    <string name="reset_network_desc" msgid="5547979398298881406">"Sve postavke mreže vratit će se na zadano, uključujući:\n\n"<li>"Wi‑Fi mrežu"</li>\n<li>"Prijenos podataka na mobilnoj mreži"</li>\n<li>"Bluetooth"</li></string>
    <string name="reset_esim_title" msgid="1979762943163078939">"Izbriši preuzete SIM-ove"</string>
    <string name="reset_esim_desc" msgid="5940105242448544634">"Za preuzimanje zamjenskih SIM-ova, obratite se svom mobilnom operateru. Ovim se neće otkazati nijedan paket mobilne usluge."</string>
    <string name="reset_network_button_text" msgid="2035676527471089853">"Vrati postavke na zadano"</string>
    <string name="reset_network_final_desc" msgid="4690205209934596665">"Vratiti sve postavke mreže na zadano? Ovu radnju ne možete poništiti."</string>
    <string name="reset_network_final_desc_esim" msgid="6641433458865914227">"Ponovo postaviti sve postavke mreže i izbrisati preuzete SIM-ove? Ne možete poništiti ovu radnju."</string>
    <string name="reset_network_final_button_text" msgid="1797434793741744635">"Vrati postavke na zadano"</string>
    <string name="reset_network_confirm_title" msgid="1759888886976962773">"Vratiti na zadano?"</string>
    <string name="network_reset_not_available" msgid="7188610385577164676">"Ponovno postavljanje mreže nije dostupno za ovog korisnika"</string>
    <string name="reset_network_complete_toast" msgid="787829973559541880">"Postavke mreže vraćene su na zadano"</string>
    <string name="reset_esim_error_title" msgid="2679159494023044398">"Nije moguće izbrisati SIM-ove"</string>
    <string name="reset_esim_error_msg" msgid="1356899750645220749">"Preuzete SIM-ove nije moguće izbrisati zbog greške.\n\nPonovo pokrenite uređaj i pokušajte ponovo."</string>
    <string name="master_clear_title" msgid="3531267871084279512">"Izbriši sve podatke (vraćanje na fabričke postavke)"</string>
    <string name="master_clear_short_title" msgid="8652450915870274285">"Potpuno izbriši sve podatke"</string>
    <string name="master_clear_desc" product="tablet" msgid="2314458161059569301">"Na ovaj način će se izbrisati svi podaci "<b>"interne memorije"</b>" tableta, uključujući:\n\n"<li>"Google račun"</li>\n<li>"sistemske i aplikacijske podatke i postavke"</li>\n<li>"preuzete aplikacije"</li></string>
    <string name="master_clear_desc" product="default" msgid="7647628092266675099">"Na ovaj način će se izbrisati svi podaci "<b>"interne memorije"</b>" telefona, uključujući:\n\n"<li>"Google račun"</li>\n<li>"sistemske i aplikacijske podatke i postavke"</li>\n<li>"preuzete aplikacije"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Trenutno ste prijavljeni u sljedeće račune:\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="5161423070702470742">\n\n"Drugi korisnici su prisutni na ovom uređaju.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"muziku"</li>\n<li>"fotografije"</li>\n<li>"ostale korisničke podatke"</li></string>
    <string name="master_clear_desc_also_erases_esim" msgid="6008213558725767177"><li>"eSIM kartice"</li></string>
    <string name="master_clear_desc_no_cancel_mobile_plan" msgid="5460926449093211144">\n\n"Ovim se neće otkazati vaš plan usluga mobilnog operatera."</string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Da biste izbrisali muziku, slike i ostale korisničke podatke, "<b>"USB pohrana"</b>" treba biti izbrisana."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Da biste izbrisali muziku, slike i ostale korisničke podatke, "<b>"SD kartica"</b>" treba biti izbrisana."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Izbriši USB pohranu"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Izbriši SD karticu"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Izbrišite sve podatke na internoj USB pohrani, poput muzike ili fotografija"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Izbrišite sve podatke na SD kartici, poput muzike ili fotografija"</string>
    <string name="master_clear_button_text" product="tablet" msgid="1893179883931194922">"Izbriši sve podatke"</string>
    <string name="master_clear_button_text" product="default" msgid="1893179883931194922">"Izbriši sve podatke"</string>
    <string name="master_clear_final_desc" msgid="8219087639717327355">"Izbrisat će se svi vaši lični podaci i preuzete aplikacije. Ne možete poništiti ovu radnju."</string>
    <string name="master_clear_final_desc_esim" msgid="4580223096319568030">"Izbrisat će se svi vaši lični podaci, uključujući preuzete aplikacije i SIM-ove. Ne možete poništiti ovu radnju."</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Izbriši sve"</string>
    <string name="master_clear_failed" msgid="2503230016394586353">"Resetovanje nije izvršeno jer usluga Brisanje sistema nije dostupna."</string>
    <string name="master_clear_confirm_title" msgid="1134724452049918413">"Izbrisati sve podatke?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Vraćanje na fabričke postavke nije dostupno za ovog korisnika"</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Brisanje u toku"</string>
    <string name="master_clear_progress_text" msgid="6559096229480527510">"Pričekajte..."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Postavke poziva"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Postavite govornu poštu, prosljeđivanje poziva, poziv na čekanju, ID pozivaoca"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Povezivanje mobitela USB-om"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Prijenosna pristupna tačka"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Dijeljenje Bluetooth veze"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Povezivanje putem mobitela"</string>
    <string name="tether_settings_title_all" msgid="3058586928118801157">"Pristupna tačka i povezivanje putem mobitela"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="930464462687425777">"Pristupna tačka je uključena, veza se dijeli"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="3473671453891735907">"Pristupna tačka je uključena"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="1618256180720077354">"Povezivanje putem mobitela"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="1576908608463904152">"Dok je upaljena Ušteda podataka nije moguće povezati uređaj niti koristiti prijenosne pristupne tačke"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Dijeljenje USB veze"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3711893746716442706">"Dijeljenje internetske veze telefona putem USB-a"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="2292916486612255069">"Dijeljenje internetske veze tableta putem USB-a"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Dijeljenje Bluetooth veze"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="8828883800511737077">"Dijeljenje internetske veze tableta putem Bluetootha"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="1904667146601254812">"Dijeljenje internetske veze telefona putem Bluetootha"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="376389105752995580">"Dijeljenje internetske veze uređaja <xliff:g id="DEVICE_NAME">%1$d</xliff:g> putem Bluetootha"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="2135590598511178690">"Nije se moguće povezati sa više od <xliff:g id="MAXCONNECTION">%1$d</xliff:g> uređaja."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"Prestat će se dijeliti veza s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="tethering_footer_info" msgid="7112228674056306147">"Koristite pristupnu tačku i povezivanje putem mobitela za pružanje interneta drugim uređajima putem veze za prijenos podataka na mobilnoj mreži. Aplikacije također mogu kreirati pristupne tačke za dijeljenje sadržaja s uređajima u blizini."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Pomoć"</string>
    <string name="network_settings_title" msgid="2876509814832830757">"Mobilna mreža"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Paket mobilne usluge"</string>
    <string name="sms_application_title" msgid="4903928270533250448">"Aplikacija za SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Promijeniti aplikaciju za SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Koristiti <xliff:g id="NEW_APP">%1$s</xliff:g> umjesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> kao aplikaciju za SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Koristiti <xliff:g id="NEW_APP">%s</xliff:g> kao aplikaciju za SMS?"</string>
    <string name="network_scorer_picker_title" msgid="6383879578279046456">"Ocjenjivač mreže"</string>
    <string name="network_scorer_picker_none_preference" msgid="9028375117241790936">"Ništa"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"Promijeniti WiFi asistenta?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"Želite li koristiti aplikaciju <xliff:g id="NEW_APP">%1$s</xliff:g> umjesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> za upravljanje mrežnim vezama?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="7444620909047611601">"Koristiti <xliff:g id="NEW_APP">%s</xliff:g> za upravljanje vašim mrežnim vezama?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Nepoznati SIM operater"</string>
    <string name="mobile_no_provisioning_url" msgid="9053814051811634125">"<xliff:g id="OPERATOR">%1$s</xliff:g> nema poznatu web lokaciju za omogućavanje upotrebe"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Umetnite SIM karticu i ponovo pokrenite uređaj"</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Povežite se na Internet"</string>
    <string name="location_title" msgid="1029961368397484576">"Moja lokacija"</string>
    <string name="managed_profile_location_switch_title" msgid="6712332547063039683">"Lokacija za profil za Work"</string>
    <string name="location_app_level_permissions" msgid="2777033567595680764">"Odobrenje za aplikaciju"</string>
    <string name="location_app_permission_summary_location_off" msgid="2790918244874943070">"Lokacija je isključena"</string>
    <plurals name="location_app_permission_summary_location_on" formatted="false" msgid="6755614454444493071">
      <item quantity="one">Neograničen pristup ima sljedeći broj aplikacija: <xliff:g id="BACKGROUND_LOCATION_APP_COUNT_2">%1$d</xliff:g> od <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g></item>
      <item quantity="few">Neograničen pristup ima sljedeći broj aplikacija: <xliff:g id="BACKGROUND_LOCATION_APP_COUNT_2">%1$d</xliff:g> od <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g></item>
      <item quantity="other">Neograničen pristup ima sljedeći broj aplikacija: <xliff:g id="BACKGROUND_LOCATION_APP_COUNT_2">%1$d</xliff:g> od <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g></item>
    </plurals>
    <string name="location_category_recent_location_access" msgid="4911449278675337490">"Nedavni pristup lokaciji"</string>
    <string name="location_recent_location_access_view_details" msgid="1955078513330927035">"Prikaži detalje"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"Nijedna aplikacija nije zahtijevala utvrđivanje lokacije u posljednje vrijeme"</string>
    <string name="location_no_recent_accesses" msgid="7489449862187886009">"Nijedna aplikacija nije nedavno pristupila lokaciji"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Visoka potrošnja baterije"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Niska potrošnja baterije"</string>
    <string name="location_scanning_screen_title" msgid="2297479353298444503">"Skeniranje WiFi-ja i Bluetootha"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="6216705505621183645">"Skeniranje WiFi mreže"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="2691110218127379249">"Dozvolite aplikacijama i uslugama skeniranje WiFi mreže u svakom trenutku, čak i kada je WiFi mreža isključena. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="5444989508204520019">"Skeniranje Bluetootha"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="1285526059945206128">"Dozvolite aplikacijama i uslugama skeniranje uređaja u blizini u svakom trenutku, čak i kada je Bluetooth isključen. Ovim se, naprimjer, mogu poboljšati funkcije i usluge zasnovane na lokaciji."</string>
    <string name="managed_profile_location_services" msgid="4723268446874715222">"Usluge lokacije za posao"</string>
    <string name="location_network_based" msgid="9134175479520582215">"Lokacija Wi-Fi i mob. mreža"</string>
    <string name="location_neighborhood_level" msgid="5141318121229984788">"Omogućava da aplikacije koriste Googleovu uslugu lokacije kako bi brže procijenile vašu lokaciju. Anonimni podaci o lokaciji se prikupljaju i šalju Googleu."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Lokacija utvrđena putem WiFi mreže"</string>
    <string name="location_gps" msgid="8392461023569708478">"GPS sateliti"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Dopustite aplikacijama da koriste GPS na tabletu za određivanje vaše lokacije"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Dopustite aplikacijama da koriste GPS na telefonu za određivanje vaše lokacije"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Koristi potpomognuti GPS"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Koristi server za pomoć GPS-u (uklonite oznaku kako biste smanjili korištenje mreže)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Koristi server za pomoć GPS-u (uklonite oznaku kako biste poboljšali performanse GPS-a)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Lokacija i Google pretraživanje"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Dopustite da Google koristi vašu lokaciju radi poboljšavanja rezultata pretraživanja i drugih usluga"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Pristup mojoj lokaciji"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Dopustite aplikacijama koje su zatražile vaše odobrenje da koriste informacije o vašoj lokaciji"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Izvori lokacije"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"O tabletu"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"O telefonu"</string>
    <string name="about_settings" product="device" msgid="6717640957897546887">"O uređaju"</string>
    <string name="about_settings" product="emulator" msgid="221313099578564438">"O emuliranom uređaju"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Prikaži pravne informacije, status, verziju softvera"</string>
    <string name="legal_information" msgid="5769301644270604095">"Pravne informacije"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Saradnici"</string>
    <string name="manual" msgid="3025943393642974445">"Ručno"</string>
    <string name="regulatory_labels" msgid="1293050314122427492">"Regulatorne oznake"</string>
    <string name="safety_and_regulatory_info" msgid="5103161279848427185">"Priručnik za sigurnost i propise"</string>
    <string name="copyright_title" msgid="865906688917260647">"Autorska prava"</string>
    <string name="license_title" msgid="1990487604356037871">"Licenca"</string>
    <string name="terms_title" msgid="7697580845616764642">"Odredbe i uslovi"</string>
    <string name="webview_license_title" msgid="2813507464175738967">"Sistemske WebView licence"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Pozadinske slike"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Pružaoci satelitskih slika:\n©2014 CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="8133150693616006051">"Ručno"</string>
    <string name="settings_manual_activity_unavailable" msgid="4752403782883814898">"Došlo je do problema sa učitavanjem priručnika."</string>
    <string name="settings_license_activity_title" msgid="8525014571806471216">"Licence trećih strana"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Pojavio se problem s učitavanjem licenci."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Učitavanje…"</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Sigurnosne informacije"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Sigurnosne informacije"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="142307697309858185">"Nemate vezu za prijenos podataka. Za trenutni prikaz tih informacija idite na %s s bilo kojeg računara koji je povezan na internet."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Učitavanje…"</string>
    <!-- no translation found for confirm_device_credential_pin (5308435093406166355) -->
    <skip />
    <!-- no translation found for confirm_device_credential_pattern (1350321840134412900) -->
    <skip />
    <!-- no translation found for confirm_device_credential_password (2195705238498478704) -->
    <skip />
    <string name="lockpassword_choose_your_screen_lock_header" msgid="2942199737559900752">"Postavite zaključavanje ekrana"</string>
    <string name="lockpassword_choose_your_password_message" msgid="5377842480961577542">"Postavite lozinku radi sigurnosti"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="6624409510609085450">"Da koristite otisak prsta, postavite lozinku"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="5901096361617543819">"Da koristite otisak prsta, postavite uzorak"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="6658264750811929338">"Postavite PIN radi sigurnosti"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="765344692615917183">"Da koristite otisak prsta, postavite PIN"</string>
    <string name="lockpassword_choose_your_pattern_message" msgid="8631545254345759087">"Postavite uzorak radi sigurnosti"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="1266027268220850931">"Ponovo unesite lozinku"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Potvrdite uzorak"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="7744513791910572550">"Ponovo unesite PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="5140892109439191415">"Lozinke se ne podudaraju"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="7226244811505606217">"PIN-ovi se ne podudaraju"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="2872194349688886781">"Ponovo nacrtajte uzorak"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Vrste otključavanja"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Lozinka je postavljena"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"PIN je postavljen"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Uzorak je postavljen"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="7876621019688907534">"Za potvrdu licem, postavite lozinku"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="8070525076987585344">"Za potvrdu licem, postavite uzorak"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="7304398683609714816">"Za potvrdu licem, postavite PIN"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="2920960858283879113">"Za nastavak, koristite uzorak uređaja."</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="4062335874438910487">"Za nastavak, unesite PIN uređaja."</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="3976394862548354966">"Za nastavak, unesite lozinku uređaja."</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="4435638308193361861">"Za nastavak, unesite radni uzorak"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="3730141667547002246">"Za nastavak, unesite radni PIN."</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="4250642723467019894">"Za nastavak, unesite radnu lozinku."</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="530802132223800623">"Za dodatnu sigurnost, unesite uzorak uređaja"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="7829294830078036417">"Za dodatnu sigurnost, unesite PIN uređaja"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="3552644641574796973">"Za dodatnu sigurnost, unesite lozinku uređaja"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="3003781907040522053">"Za dodatnu sigurnost, unesite radni uzorak"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="3367491332598821552">"Za dodatnu sigurnost, unesite radni PIN"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="8159775129968582940">"Za dodatnu sigurnost, unesite radnu lozinku"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6757336656791723193">"Vaš telefon je vraćen na fabričke postavke. Da koristite telefon, unesite prethodni obrazac."</string>
    <string name="lockpassword_confirm_your_pin_details_frp" msgid="826520613445990470">"Vaš telefon je vraćen na fabričke postavke. Da koristite telefon, unesite prethodni PIN."</string>
    <string name="lockpassword_confirm_your_password_details_frp" msgid="8944081074615739040">"Vaš telefon je vraćen na fabričke postavke. Da koristite telefon, unesite prethodnu lozinku."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="2898036091609128286">"Potvrdite obrazac"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="4141601774778898803">"Potvrdite PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="3762615419295360480">"Potvrdite lozinku"</string>
    <string name="lockpassword_invalid_pin" msgid="15588049067548470">"Pogrešan PIN"</string>
    <string name="lockpassword_invalid_password" msgid="4038507398784975200">"Pogrešna lozinka"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="1745247595356012176">"Pogrešan uzorak"</string>
    <string name="lock_settings_title" msgid="4213839087748988686">"Sigurnost uređaja"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Promijeni uzorak za otključavanje"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Promijeni PIN za otključavanje"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Nacrtajte uzorak za otključavanje"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Pritisnite Meni za pomoć."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Podignite prst kada završite"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Povežite najmanje <xliff:g id="NUMBER">%d</xliff:g> tačke. Pokušajte ponovo."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Uzorak snimljen"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Ponovo nacrtajte uzorak da potvrdite"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Novi uzorak za otključavanje"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Potvrdi"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Nacrtaj ponovo"</string>
    <string name="lockpattern_retry_button_text" msgid="3480423193273588166">"Obriši"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Nastavi"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Uzorak za otključavanje"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Zahtijevaj uzorak"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Mora se nacrtati uzorak za otključavanje ekrana"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Učini uzorak vidljivim"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="4864525074768391381">"Neka uzorak profila bude vidljiv"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="4389015658335522989">"Vibracija na dodir"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Dugme za napajanje zaključava"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"Osim kada ga <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> drži otključanim"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Postavi uzorak otključavanja"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Promijeni uzorak za otključavanje"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Kako nacrtati uzorak za otključavanje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="6909161623701848863">"Previše pogrešnih pokušaja. Pokušajte ponovo za <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Aplikacija nije instalirana na vašem telefonu."</string>
    <string name="lock_settings_profile_title" msgid="2121876391814535295">"Sigurnost radnog profila"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3334747927367115256">"Zaključavanje ekrana radnog profila"</string>
    <string name="lock_settings_profile_unification_title" msgid="4973102698492659123">"Koristi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unification_summary" msgid="7178299172998641303">"Koristi jedno zaključavanje za radni profil i ekran uređaja"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="4824620230229285301">"Želite li koristiti jedno zaključavanje?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="7128305504872026659">"Uređaj će koristiti zaključavanje ekrana vašeg radnog profila. Pravila za rad će se primjenjivati za oba tipa zaključavanja."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="3221303098797469900">"Zaključavanje vašeg radnog profila ne ispunjava sigurnosne zahtjeve vaše organizacije. Možete koristiti isto zaključavanje za ekran uređaja i radnog profila, ali važit će sve postavke zaključavanja radnog profila."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="8249970828159656518">"Koristi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="5943758576756482777">"Koristi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unified_summary" msgid="9008819078132993492">"Isto kao i zaključavanje ekrana uređaja"</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Upravljaj aplikacijama"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Upravljanje instaliranim aplikacijama i uklonite ih"</string>
    <string name="applications_settings" msgid="5281808652705396152">"Informacije o aplikaciji"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Upravljanje aplikacijama, postavljanje prečica za brzo pokretanje"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Postavke aplikacije"</string>
    <string name="install_applications" msgid="4872012136210802181">"Nepoznati izvori"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Dopusti sve izvore aplikacija"</string>
    <string name="recent_app_category_title" msgid="6673071268966003928">"Nedavno otvarane aplikacije"</string>
    <string name="see_all_apps_title" msgid="1317153498074308438">"Prikaži sve aplikacije: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="install_all_warning" product="tablet" msgid="8310489909586138165">"Vaši podaci na tabletu i lični podaci su više izloženi napadima aplikacija iz nepoznatih izvora. Instaliranjem aplikacija iz takvih izvora, saglasni ste da ste vi odgovorni za bilo kakvu štetu na telefonu ili gubitak podataka koji mogu nastati korištenjem tih aplikacija."</string>
    <string name="install_all_warning" product="default" msgid="1952257127370115988">"Vaši podaci na telefonu i lični podaci više su izloženi napadima aplikacija iz nepoznatih izvora. Instaliranjem aplikacija iz takvih izvora, saglasni ste da ste vi odgovorni za bilo kakvu štetu na telefonu ili gubitak podataka koji mogu nastati korištenjem tih aplikacija."</string>
    <string name="install_all_warning" product="device" msgid="3648003301476423145">"Podaci s vašeg uređaja i vaši lični podaci su izloženiji napadima nepoznatih aplikacija. Instaliranjem aplikacija iz ovog izvora prihvatate odgovornost za bilo kakvu štetu na uređaju ili gubitak podataka uzrokovan njihovim korištenjem."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Napredne postavke"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Omogućite više opcija postavki"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Informacije o aplikaciji"</string>
    <string name="storage_label" msgid="8700867073480107253">"Pohrana"</string>
    <string name="auto_launch_label" msgid="2669236885531442195">"Zadano otvaranje"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Zadane vrijednosti"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Kompatibilnost ekrana"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Odobrenja"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Keš memorija"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Obriši keš memoriju"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Keš memorija"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="3983110543017963732">
      <item quantity="one">%d stavka</item>
      <item quantity="few">%d stavke</item>
      <item quantity="other">%d stavki</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="8575655132961012158">"Pristup je slobodan"</string>
    <string name="controls_label" msgid="7611113077086853799">"Kontrole"</string>
    <string name="force_stop" msgid="7435006169872876756">"Prisilno zaustavi"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Ukupno"</string>
    <string name="application_size_label" msgid="7376689739076506885">"Veličina aplikacije"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Aplikacija USB pohrane"</string>
    <string name="data_size_label" msgid="6117971066063850416">"Korisnički podaci"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Podaci USB pohrane"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"SD kartica"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Deinstaliraj"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Deinstaliraj za sve korisnike"</string>
    <string name="install_text" msgid="884360662922471113">"Instaliraj"</string>
    <string name="disable_text" msgid="6544054052049395202">"Onemogući"</string>
    <string name="enable_text" msgid="9217362512327828987">"Omogući"</string>
    <string name="clear_user_data_text" msgid="355574089263023363">"Obriši pohranu"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Deinstaliraj ažuriranja"</string>
    <string name="auto_launch_enable_text" msgid="4275746249511874845">"Odabrali ste zadano pokretanje ove aplikacije za neke radnje."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="566822577792032925">"Odabrali ste da ovoj aplikaciji dodijelite odobrenje za kreiranje vidžeta i pristup njihovim podacima."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Nisu postavljene zadane vrijednosti."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Obriši zadane vrijednosti"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Ova aplikacija možda nije dizajnirana za vaš ekran. Ovdje možete odrediti kako se ona prilagođava vašem ekranu."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Pitaj prilikom pokretanja"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Skaliraj aplikaciju"</string>
    <string name="unknown" msgid="1592123443519355854">"Nepoznato"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Poredaj po imenu"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Poredaj po veličini"</string>
    <string name="sort_order_recent_notification" msgid="6064103501358974282">"Najskorije"</string>
    <string name="sort_order_frequent_notification" msgid="1733204081305830670">"Najčešće"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Prikaži pokrenute usluge"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Prikaži procese iz keš memorije"</string>
    <string name="default_emergency_app" msgid="1951760659640369980">"Aplikacija za hitne situacije"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Vrati postavke aplikacije na zadano"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Vratiti postavke aplikacije na zadano?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"Ovim će se vratiti sve postavke na zadano za:\n\n "<li>"onemogućene aplikacije"</li>\n" "<li>"obavještenja za onemogućene aplikacije"</li>\n" "<li>"zadane aplikacije za radnje"</li>\n" "<li>"ograničenja pozadinskih podataka za aplikacije"</li>\n" "<li>"sva ograničenja za odobrenja"</li>\n\n" Nećete izgubiti podatke iz aplikacija."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Vrati aplikacije na zadano"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Upravljaj prostorom"</string>
    <string name="filter" msgid="2018011724373033887">"Filter"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Odaberite opcije filtera"</string>
    <string name="filter_apps_all" msgid="8899612398848280352">"Sve aplikacije"</string>
    <string name="filter_apps_disabled" msgid="5862632369555319938">"Onemogućene aplikacije"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Preuzeto"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Pokretanje"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"USB pohrana"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Na SD kartici"</string>
    <string name="not_installed" msgid="2797554494953450291">"Nije instal. za ovog korisnika"</string>
    <string name="installed" msgid="3070865169422600098">"Instalirano"</string>
    <string name="no_applications" msgid="7336588977497084921">"Nema aplikacija."</string>
    <string name="internal_storage" msgid="1584700623164275282">"Interna pohrana"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Ponovno izračunavanje veličine…"</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Izbrisati podatke aplikacija?"</string>
    <string name="clear_data_dlg_text" msgid="3951297329833822490">"Svi podaci ove aplikacije će biti trajno izbrisani. To uključuje sve fajlove, postavke, račune, baze podataka itd."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"Uredu"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Otkaži"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="4893589904687340011">"Aplikacija nije pronađena u listi instaliranih aplikacija."</string>
    <string name="clear_failed_dlg_text" msgid="8651231637137025815">"Pohrana za aplikaciju nije obrisana."</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> i <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_two_unrelated_items" msgid="1873827777191260824">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="computing_size" msgid="1599186977475211186">"Računanje…"</string>
    <string name="invalid_size_value" msgid="1582744272718752951">"Nije bilo moguće izračunati veličinu paketa."</string>
    <string name="version_text" msgid="9189073826278676425">"verzija <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Premjesti"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Premjesti na tablet"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Premjesti na telefon"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Premjesti na USB pohranu"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Premjesti na SD karticu"</string>
    <string name="another_migration_already_in_progress" msgid="7817354268848365487">"Druga migracija je već u toku."</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Nema dovoljno prostora za pohranu."</string>
    <string name="does_not_exist" msgid="1501243985586067053">"Aplikacija ne postoji."</string>
    <string name="invalid_location" msgid="4354595459063675191">"Lokacija instaliranja nije važeća."</string>
    <string name="system_package" msgid="1352722848400644991">"Ažuriranja sistema se ne mogu instalirati na vanjske medijume."</string>
    <string name="move_error_device_admin" msgid="8673026002690505763">"Aplikaciju administratora uređaja nije moguće instalirati na vanjski medij"</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Prisilno zaustaviti?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Ako prisilno zaustavite aplikaciju, moguće je da će se ponašati nepredviđeno."</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Željena lokacija za instaliranje"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Promijenite preferiranu lokaciju za instaliranje novih aplikacija"</string>
    <string name="app_disable_dlg_positive" msgid="7375627244201714263">"Onemogući aplikaciju"</string>
    <string name="app_disable_dlg_text" msgid="1234624266290478136">"Ako onemogućite ovu aplikaciju, moguće je da Android i druge aplikacije više neće funkcionirati ispravno. Vodite računa da ovu aplikaciju ne možete izbrisati jer je unaprijed instalirana na vašem uređaju. Ako onemogućite, isključit ćete ovu aplikaciju i sakriti je na uređaju."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Isključiti obavještenja?"</string>
    <string name="app_install_details_group_title" msgid="7084623031296083574">"Trgovina"</string>
    <string name="app_install_details_title" msgid="6905279702654975207">"Detalji o aplikaciji"</string>
    <string name="app_install_details_summary" msgid="6464796332049327547">"Aplikacija je instalirana iz trgovine: <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="4529934403276907045">"Više informacija na <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"Pokrenuto"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Nikad korišteno)"</string>
    <string name="no_default_apps" msgid="2915315663141025400">"Nema zadanih aplikacija."</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Korištenje pohrane"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Prikaži pohranu koju koriste aplikacije"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Ponovno pokretanje"</string>
    <string name="cached" msgid="1059590879740175019">"Keširani procesi u pozadini"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Ništa nije pokrenuto."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Pokrenula aplikacija."</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"Slobodno <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"Iskorišteno <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Korisnik: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Uklonjen korisnik"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluge/a"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces/a i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces/a i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluge/a"</string>
    <string name="running_processes_header_title" msgid="6588371727640789560">"Memorija uređaja"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Iskorištenost RAM-a aplikacije"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Sistem"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Aplikacije"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"Slobodno"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Iskorišteno"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"Keširano"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM-a"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Pokrenuta aplikacija"</string>
    <string name="no_services" msgid="7133900764462288263">"Nije aktivno"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Usluge"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Procesi"</string>
    <string name="service_stop" msgid="6369807553277527248">"Zaustavi"</string>
    <string name="service_manage" msgid="1876642087421959194">"Postavke"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Ovu uslugu je pokrenula njena aplikacija. Zaustavljanje može izazvati prekid rada aplikacije."</string>
    <string name="heavy_weight_stop_description" msgid="6050413065144035971">"Ovu aplikaciju nije moguće zaustaviti na siguran način. Ako je zaustavite mogli biste izgubiti dio sadržaja na kome trenutno radite."</string>
    <string name="background_process_stop_description" msgid="3834163804031287685">"Ovo je stari aplikacijski proces ostavljen u funkciji za slučaj da zatreba. Obično nema razloga za njegovo zaustavljanje."</string>
    <string name="service_manage_description" msgid="479683614471552426">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: trenutno je u upotrebi. Dodirnite Postavke da kontrolirate uslugu."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Glavni proces se koristi."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Usluga <xliff:g id="COMP_NAME">%1$s</xliff:g> se koristi."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Pružalac <xliff:g id="COMP_NAME">%1$s</xliff:g> se koristi."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Zaustaviti sistemsku uslugu?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Ako zaustavite ovu uslugu, neke funkcije tableta će možda prestati pravilno funkcionirati sve dok ne isključite i zatim ponovo uključite tablet."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Ako zaustavite ovu uslugu, neke funkcije telefona će možda prestati pravilno funkcionirati sve dok ne isključite i zatim ponovo uključite tablet."</string>
    <string name="language_input_gesture_title" msgid="8749227808244881255">"Jezici, unos i pokreti"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="7219895055450633449"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="756147879200943161"></string>
    <string name="language_input_gesture_summary_off" msgid="4617198819416948217"></string>
    <string name="language_settings" msgid="8758655933029560944">"Jezici i unos"</string>
    <string name="language_empty_list_user_restricted" msgid="5984015900102140696">"Nemate odobrenje za promjenu jezika na uređaju."</string>
    <string name="language_keyboard_settings_title" msgid="3709159207482544398">"Jezici i unos"</string>
    <string name="input_assistance" msgid="7392740255874966807">"Alati"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Tastatura i načini unosa"</string>
    <string name="phone_language" msgid="7116581601133118044">"Jezici"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Automatska zamjena"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Ispravi pogrešno napisane riječi"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Automatsko veliko slovo"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Piši prvu riječ u rečenici velikim početnim slovom."</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Automatska interpunkcija"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Postavke fizičke tastature"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Pritisnite tipku za razmak dva puta kako biste umetnuli \".\""</string>
    <string name="show_password" msgid="4837897357002495384">"Prikaži lozinke"</string>
    <string name="show_password_summary" msgid="3365397574784829969">"Kratko prikazivanje znakova dok se upisuju"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Ovaj alat za provjeru pravopisa u mogućnosti je da prikuplja sav tekst koji upišete, uključujući lične podatke kao što su lozinke i brojevi kreditnih kartica. Alat je omogućila aplikacija <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Da li želite koristiti ovaj alat za provjeru pravopisa?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Postavke"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Jezik"</string>
    <string name="keyboard_and_input_methods_category" msgid="4580907662493721491">"Tastature"</string>
    <string name="virtual_keyboard_category" msgid="1012830752318677119">"Virtuelna tastatura"</string>
    <string name="available_virtual_keyboard_category" msgid="7645766574969139819">"Dostupna virtualna tastatura"</string>
    <string name="add_virtual_keyboard" msgid="3302152381456516928">"Upravljajte tastaturama"</string>
    <string name="keyboard_assistance_category" msgid="5843634175231134014">"Pomoć za tastaturu"</string>
    <string name="physical_keyboard_title" msgid="8285149877925752042">"Fizička tastatura"</string>
    <string name="show_ime" msgid="2658582193437188227">"Prikaz virtuelne tastature"</string>
    <string name="show_ime_summary" msgid="8164993045923240698">"Zadržava se na ekranu dok je fizička tastatura aktivna"</string>
    <string name="keyboard_shortcuts_helper" msgid="4839453720463798145">"Pomoć za prečice na tastaturi"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5871299901459743288">"Prikaz dostupnih prečica"</string>
    <string name="language_and_input_for_work_category_title" msgid="3825906835886710498">"Tastatura i alati radnog profila"</string>
    <string name="virtual_keyboards_for_work_title" msgid="2646946676585390499">"Virutuelna tastatura za posao"</string>
    <string name="default_keyboard_layout" msgid="4172606673510531271">"Zadano"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Brzina pokazivača"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Kontroler za igre"</string>
    <string name="vibrate_input_devices" msgid="421936611134697943">"Preusmjeravanje vibracije"</string>
    <string name="vibrate_input_devices_summary" msgid="82093256723774584">"Pošalji vibraciju na kontroler za igre kada je povezan."</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Odaberite raspored tastature"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Postavi rasporede tastature"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Da biste izvršili prebacivanje, pritisnite kombinaciju tipki \"Control-Space\""</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Zadano"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Rasporedi tastature"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Lični rječnik"</string>
    <string name="user_dict_settings_for_work_title" msgid="7634659414713254169">"Lični rječnik za posao"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Dodaj"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Dodaj u rječnik"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Fraza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Više opcija"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Manje opcija"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"Uredu"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Riječ:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Prečica:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Jezik:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Unesite riječ"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Opcionalna prečica"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Uredi riječ"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Uređivanje"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Izbriši"</string>
    <string name="user_dict_settings_empty_text" msgid="1971969756133074922">"Nemate nijednu riječ u korisničkom rječniku. Da dodate riječ, dodirnite dugme Dodaj (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Za sve jezike"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Više jezika…"</string>
    <string name="testing" msgid="6584352735303604146">"Testiranje"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informacije o tabletu"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Informacije o telefonu"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Unos teksta"</string>
    <string name="input_method" msgid="5434026103176856164">"Način unosa"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Aktualna tastatura"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Birač načina unosa"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automatski"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Uvijek prikaži"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Uvijek sakrij"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Postavite načine unosa"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Postavke"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Postavke"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"<xliff:g id="IME_NAME">%1$s</xliff:g> postavke"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Odaberite aktivne načine unosa"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Postavke tastature na ekranu"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Fizička tastatura"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Postavke fizičke tastature"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Odaberite gadžet"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Odaberi vidžet"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Kreirati vidžet i omogućiti pristup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Nakon što kreirate vidžet, <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> može pristupiti svim podacima koje prikazuje."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Uvijek dopusti da aplikacija <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> kreira vidžete i koristi njihove podatke"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Statistika korištenja"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Statistika korištenja"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Poredaj po:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplikacija"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Posljednji put korišteno"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Vrijeme korištenja"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Pristupačnost"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Postavke pristupačnosti"</string>
    <string name="accessibility_settings_summary" msgid="981260486011624939">"Čitači ekrana, ekran, kontrole za interakciju"</string>
    <string name="vision_settings_title" msgid="4204111425716868288">"Postavke za vid"</string>
    <string name="vision_settings_description" msgid="5679491180156408260">"Ovaj uređaj možete prilagoditi svojim potrebama. Funkcije pristupačnosti se mogu kasnije promijeniti u Postavkama."</string>
    <string name="vision_settings_suggestion_title" msgid="8058794060304707004">"Promijenite veličinu fonta"</string>
    <string name="screen_reader_category_title" msgid="7739154903913400641">"Čitači ekrana"</string>
    <string name="audio_and_captions_category_title" msgid="3420727114421447524">"Zvuk i tekst na ekranu"</string>
    <string name="display_category_title" msgid="685461049938269166">"Prikaz"</string>
    <string name="interaction_control_category_title" msgid="7836591031872839151">"Kontrole za interakciju"</string>
    <string name="user_installed_services_category_title" msgid="6426376488922158647">"Preuzeti servisi"</string>
    <string name="experimental_category_title" msgid="5272318666666893547">"Eksperimentalno"</string>
    <string name="feature_flags_dashboard_title" msgid="778619522682769966">"Oznake funkcija"</string>
    <string name="talkback_title" msgid="7912059827205988080">"Talkback"</string>
    <string name="talkback_summary" msgid="8331244650729024963">"Čitač ekrana prvenstveno za slijepe i slabovidne osobe"</string>
    <string name="select_to_speak_summary" msgid="4282846695497544515">"Dodirnite stavke na ekranu da se naglas pročitaju"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Titlovi"</string>
    <string name="accessibility_screen_magnification_title" msgid="6001128808776506021">"Uvećanje"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3719929521571489913">"Uvećavanje trostrukim dodirom"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="7141753038957538230">"Uvećavanje pomoću dugmeta"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="2760906043221923793">"Uvećavanje pomoću dugmeta i trostrukog dodira"</string>
    <string name="accessibility_preference_magnification_summary" msgid="5867883657521404509">"Uvećajte prikaz na ekranu"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="3411979839172752057">"Dodirnite tri puta da zumirate"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="3693116360267980492">"Dodirnite dugme da zumirate"</string>
    <string name="accessibility_screen_magnification_summary" msgid="5258868553337478505"><b>"Da zumirate "</b>", brzo dodirnite ekran 3 puta.\n"<ul><li>"Povlačite s 2 ili više prstiju da pomjerate prikaz"</li>\n<li>"Sastavite 2 ili više prstiju da podesite zumiranje"</li></ul>\n\n<b>"Da privremeno zumirate prikaz"</b>", brzo dodirnite ekran 3 puta i zadržite prst na trećem dodiru.\n"<ul><li>"Povlačite prstom da pregledate ekran"</li>\n<li>"Podignite prst da umanjite prikaz"</li></ul>\n\n"Ne možete uvećati prikaz na tastaturi i navigacionoj traci."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="1996584694050087161">"Kada je uključena funkcija uvećavanja, koristite dugme Pristupačnost na dnu ekrana da brzo uvećate.\n\n"<b>"Da zumirate"</b>", dodirnite dugme Pristupačnost, zatim dodirnite bilo gdje na ekranu.\n"<ul><li>"Povlačite s 2 ili više prstiju da pomjerate prikaz."</li>\n<li>"Sastavite 2 ili više prstiju da podesite zumiranje. "</li></ul>\n\n<b>"Da privremeno zumirate"</b>", dodirnite dugme Pristupačnost, zatim dodirnite i držite bilo gdje na ekranu.\n"<ul><li>"Povlačite prstom da pregledate ekran"</li>\n<li>"Podignite prst da umanjite prikaz"</li></ul>\n\n"Ne možete uvećati prikaz na tastaturi i navigacionoj traci."</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="70533120652758190">"Dugme Pirstupačnost podešeno je za aktiviranje usluge <xliff:g id="SERVICE">%1$s</xliff:g>. Da koristite uvećanje dodirnite i držite dugme Pristupačnost, zatim odaberite uvećanje."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="2048884356166982714">"Prečica tipke za jačinu zvuka"</string>
    <string name="accessibility_shortcut_service_title" msgid="4779360749706905640">"Usluga prečice"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="5490636079625489534">"Dopusti iz zaključanog ekrana"</string>
    <string name="accessibility_shortcut_description" msgid="1765853731190717372">"Kada je uključena prečica, možete pritisnuti obje tipke za podešavanje jačine zvuka i držati ih 3 sekunde da pokrenete funkciju pristupačnosti."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Tekst visokog kontrasta"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Automatsko ažuriranje uvećanja ekrana"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Ažurira uvećanje ekrana kod prelaza aplikacija"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Dugme uklj./isklj. prekida poziv"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="535173100516295580">"Veliki pokazivač miša"</string>
    <string name="accessibility_disable_animations" msgid="5876035711526394795">"Uklanjanje animacija"</string>
    <string name="accessibility_toggle_master_mono_title" msgid="4363806997971905302">"Mono audio"</string>
    <string name="accessibility_toggle_master_mono_summary" msgid="5634277025251530927">"Kombiniranje kanala prilikom reprodukcije zvuka"</string>
    <string name="accessibility_toggle_master_balance_title" msgid="551441665399043471">"Audio balans"</string>
    <string name="accessibility_toggle_master_balance_left_label" msgid="840973259765894310">"Lijevo"</string>
    <string name="accessibility_toggle_master_balance_right_label" msgid="7349959407092157385">"Desni"</string>
    <string name="accessibility_timeout_default" msgid="8316215621219570607">"Zadano"</string>
    <string name="accessibility_timeout_10secs" msgid="1976492627730727871">"10 sekundi"</string>
    <string name="accessibility_timeout_30secs" msgid="8055710148052265579">"30 sekundi"</string>
    <string name="accessibility_timeout_1min" msgid="6314276027668784112">"1 minuta"</string>
    <string name="accessibility_timeout_2mins" msgid="9062685014853095180">"2 minute"</string>
    <string name="accessibility_content_timeout_preference_title" msgid="5647118549024271497">"Vrijeme za čitanje"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="3076566452307147390">"Vrijeme za poduzimanje radnje"</string>
    <string name="accessibility_content_timeout_preference_summary" msgid="2637322628166175371">"Odaberite koliko dugo želite da se poruke koje trebate pročitati prikazuju. One će biti vidljive samo privremeno.\n\nOvu postavku ne podržavaju sve aplikacije."</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="6557680564604287459">"Odaberite koliko dugo želite da se poruke koje od vas zahtijevaju da poduzmete radnju prikazuju, a koje će biti vidljive samo privremeno.\n\nOvu postavku ne podržavaju sve aplikacije."</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Odgoda za dodirivanje i držanje"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Inverzija boja"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="7052959202195368109">"Može uticati na performanse"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2434062071927416098">"Vrijeme zadržavanja"</string>
    <string name="accessibility_autoclick_description" msgid="4908960598910896933">"Ako koristite miš, kursor možete podesiti tako da automatski preuzme radnju kada se prestane kretati određeno vrijeme."</string>
    <string name="accessibility_autoclick_delay_preference_title" msgid="3962261178385106006">"Odgoda prije klika"</string>
    <string name="accessibility_vibration_settings_title" msgid="3453277326300320803">"Vibracija"</string>
    <string name="accessibility_notification_vibration_title" msgid="3009997451790678444">"Vibracija obavještenja"</string>
    <string name="accessibility_ring_vibration_title" msgid="5369395955680650778">"Vibracija pri zvonu"</string>
    <string name="accessibility_touch_vibration_title" msgid="7931823772673770492">"Vibracija pri dodiru"</string>
    <string name="accessibility_service_master_switch_title" msgid="6835441300276358239">"Koristi uslugu"</string>
    <string name="accessibility_daltonizer_master_switch_title" msgid="8655284637968823154">"Koristi ispravku boje"</string>
    <string name="accessibility_caption_master_switch_title" msgid="4010227386676077826">"Koristi natpise"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="974461729380409972">"Nastavi"</string>
    <string name="accessibility_hearingaid_title" msgid="8312145423610648518">"Slušni aparat"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="6240237523789614599">"Nije povezan nijedan slušni aparat"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="2947474468412309778">"Dodaj slušne aparate"</string>
    <string name="accessibility_hearingaid_pair_instructions_first_message" msgid="3912093691643131154">"Da uparite slušne aparate, pronađite i dodirnite svoj uređaj na sljedećem ekranu."</string>
    <string name="accessibility_hearingaid_pair_instructions_second_message" msgid="5596683393607650243">"Provjerite jesu li slušni aparati u načinu rada uparivanja."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="3924362383258688984">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> aktivan"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="3160782397139295486">
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> slušni aparat sačuvan</item>
      <item quantity="few"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> slušna aparata sačuvana</item>
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> slušnih aparata sačuvano</item>
    </plurals>
    <string name="accessibility_summary_state_enabled" msgid="7914278500885887763">"Uključeno"</string>
    <string name="accessibility_summary_state_disabled" msgid="2984230257590246745">"Isključeno"</string>
    <string name="accessibility_summary_state_stopped" msgid="1144156815350270876">"Ne radi. Dodirnite za informacije."</string>
    <string name="accessibility_description_state_stopped" msgid="6953539746047006596">"Ova usluga ne radi ispravno."</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Prikaži u Brzim postavkama"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Način rada za korekciju"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_extremely_short_delay" formatted="false" msgid="7340347830562315800">
      <item quantity="one">Izuzetno kratko kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Izuzetno kratko kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Izuzetno kratko kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_short_delay" formatted="false" msgid="5589565607652364932">
      <item quantity="one">Veoma kratko kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Veoma kratko kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Veoma kratko kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5887754135102768400">
      <item quantity="one">Kratko kašnjenje ( <xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Kratko kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Kratko kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="6340683412750219405">
      <item quantity="one">Značajno kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Značajno kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Značajno kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_long_delay" formatted="false" msgid="3503199424330634970">
      <item quantity="one">Veoma dugo kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Veoma dugo kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Veoma dugo kašnjenje (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <string name="accessibility_vibration_summary" msgid="4272038147476749536">"Jačina zvuka zvona <xliff:g id="SUMMARY_RING">%1$s</xliff:g>, obavještenje <xliff:g id="SUMMARY_NOTIFICATION">%2$s</xliff:g>, dodir <xliff:g id="SUMMARY_TOUCH">%3$s</xliff:g>"</string>
    <string name="accessibility_vibration_summary_off" msgid="1753566394591809629">"Zvono i obavještenje su postavljeni na isključeno"</string>
    <string name="accessibility_vibration_summary_low" msgid="7628418309029013867">"Zvono i obavještenje su postavljeni na slabo"</string>
    <string name="accessibility_vibration_summary_medium" msgid="3422136736880414093">"Zvono i obavještenje su postavljeni na srednje"</string>
    <string name="accessibility_vibration_summary_high" msgid="3239807793182635729">"Zvono i obavještenje su postavljeni na jako"</string>
    <string name="accessibility_vibration_intensity_off" msgid="4613890213008630847">"Isključeno"</string>
    <string name="accessibility_vibration_intensity_low" msgid="2017572546489862987">"Slabo"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="3782136025830279769">"Srednje"</string>
    <string name="accessibility_vibration_intensity_high" msgid="2543921139337952491">"Jako"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Postavke"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Uključeno"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Isključeno"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Pregled"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Standardne opcije"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Jezik"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Veličina teksta"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Stil titlova"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Prilagođene opcije"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Boja pozadine"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Prozirnost pozadine"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Boja prozora za titlove"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Prozirnost prozora naslova"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Boja teksta"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Prozirnost teksta"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Boja rubova"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Vrsta rubova"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Skup fontova"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Stilovi će izgledati ovako"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Zadano"</string>
    <string name="color_title" msgid="4258931051732243983">"Boja"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"Zadano"</string>
    <string name="color_none" msgid="3475640044925814795">"Nema boje"</string>
    <string name="color_white" msgid="8045195170201590239">"Bijela"</string>
    <string name="color_gray" msgid="9192312087142726313">"Siva"</string>
    <string name="color_black" msgid="7517353520909872561">"Crna"</string>
    <string name="color_red" msgid="4949354900304125428">"Crvena"</string>
    <string name="color_green" msgid="5537717328428845841">"Zelena"</string>
    <string name="color_blue" msgid="7731984529016953223">"Plava"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Cijan"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Žuta"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Magenta"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Koristiti <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"Usluga <xliff:g id="SERVICE">%1$s</xliff:g> treba da:"</string>
    <string name="touch_filtered_warning" msgid="8644034725268915030">"Aplikacija nije dala odobrenje za zahtjev pa postavke ne mogu potvrditi vaš odgovor."</string>
    <string name="enable_service_encryption_warning" msgid="3064686622453974606">"Ukoliko uključite uslugu <xliff:g id="SERVICE">%1$s</xliff:g>, uređaj neće koristiti zaključavanje ekrana za poboljšanje šifriranja podataka."</string>
    <string name="secure_lock_encryption_warning" msgid="460911459695077779">"Pošto ste uključili uslugu pristupačnosti, vaš uređaj neće koristiti zaključavanje ekrana za poboljšanje šifriranja podataka."</string>
    <string name="enable_service_pattern_reason" msgid="777577618063306751">"Uključivanje usluge <xliff:g id="SERVICE">%1$s</xliff:g> utiče na šifriranje podataka, stoga je potrebno da potvrdite svoj obrazac."</string>
    <string name="enable_service_pin_reason" msgid="7882035264853248228">"Uključivanje usluge <xliff:g id="SERVICE">%1$s</xliff:g> utiče na šifriranje podataka, stoga je potrebno da potvrdite svoj PIN."</string>
    <string name="enable_service_password_reason" msgid="1224075277603097951">"Uključivanje usluge <xliff:g id="SERVICE">%1$s</xliff:g> utiče na šifriranje podataka, stoga je potrebno da potvrdite lozinku."</string>
    <string name="accessibility_service_warning" msgid="846312597054899472">"Usluga <xliff:g id="SERVICE">%1$s</xliff:g> zahtijeva potpunu kontrolu ovog uređaja. Usluga može čitati sadržaj ekrana i djelovati u ime korisnika s potrebama za pristupačnost. Ovaj nivo kontrole nije prikladan za većinu aplikacija."</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Zaustaviti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="2247101878627941561">"Uslugu <xliff:g id="SERVICE">%1$s</xliff:g> možete zaustaviti dodirom na \"Uredu\"."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Nema instaliranih usluga"</string>
    <string name="accessibility_no_service_selected" msgid="2840969718780083998">"Nije odabrana usluga"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Nije naveden opis."</string>
    <string name="settings_button" msgid="3006713718908152930">"Postavke"</string>
    <string name="print_settings" msgid="4742428530112487843">"Štampanje"</string>
    <string name="print_settings_summary_no_service" msgid="6354322414246865875">"Isključeno"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="6005468025646083029">
      <item quantity="one">Uključena je <xliff:g id="COUNT">%1$d</xliff:g> usluga štampanja</item>
      <item quantity="few">Uključene su <xliff:g id="COUNT">%1$d</xliff:g> usluge štampanja</item>
      <item quantity="other">Uključeno je <xliff:g id="COUNT">%1$d</xliff:g> usluga štampanja</item>
    </plurals>
    <plurals name="print_jobs_summary" formatted="false" msgid="5810106725778525400">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> zadatak za štampanje</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g>zadatka za štampanje</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g>zadataka za štampanje</item>
    </plurals>
    <string name="print_settings_title" msgid="3685449667822217816">"Usluge štampanja"</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Nema instaliranih usluga"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Nije pronađen nijedan štampač"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Postavke"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Dodaj pisače"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Uključeno"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Isključeno"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Dodajte uslugu"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Dodaj štampač"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Pretraži"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Pretraživanje štampača"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Usluga je onemogućena"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Zadaci štampanja"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Zadatak ispisivanja"</string>
    <string name="print_restart" msgid="8373999687329384202">"Ponovo pokreni"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Otkaži"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="1228890182762324249">"Konfiguriranje za <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Štampa se <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Otkazuje se <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Greška pisača <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Štampač je blokirao <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Okvir za pretraživanje je prikazan"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Okvir za pretraživanje je skriven"</string>
    <string name="printer_info_desc" msgid="5824995108703060003">"Više informacija o ovom štampaču"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Baterija"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Šta je sve koristilo bateriju"</string>
    <string name="power_usage_not_available" msgid="3109326074656512387">"Nema podataka o potrošnji baterije."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"Preostalo <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do pune baterije"</string>
    <string name="background_activity_title" msgid="8482171736539410135">"Ograničenje rada u pozadini"</string>
    <string name="background_activity_summary" msgid="8140094430510517362">"Dopustite aplikaciji da radi u pozadini"</string>
    <string name="background_activity_summary_disabled" msgid="3710669050484599847">"Aplikaciji nije dopušteno da radi u pozadini"</string>
    <string name="background_activity_summary_whitelisted" msgid="1079899502347973947">"Nije moguće ograničiti upotrebu u pozadini"</string>
    <string name="background_activity_warning_dialog_title" msgid="2216249969149568871">"Ograničiti aktivnost u pozadini?"</string>
    <string name="background_activity_warning_dialog_text" msgid="7049624449246121981">"Ako aplikaciji ograničite aktivnost u pozadini, može raditi nepravilno"</string>
    <string name="background_activity_disabled_dialog_text" msgid="6133420589651880824">"Aplikaciju ne možete ograničiti jer nije postavljena optimizacija baterije.\n\nDa je ograničite prvo uključite optimizaciju."</string>
    <string name="device_screen_usage" msgid="3386088035570409683">"Korištenje ekrana od potpune napunjenosti"</string>
    <string name="power_usage_list_summary" msgid="5584049564906462506">"Potrošnja baterije od posljednjeg potpunog punjenja"</string>
    <string name="screen_usage_summary" msgid="6687403051423153550">"Vrijeme koliko je ekran uključen od potpune napunjenosti"</string>
    <string name="device_usage_list_summary" msgid="5623036661468763251">"Korištenje uređaja od potpune napunjenosti"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Potrošnja baterije od isključivanja s napajanja"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Potrošnja baterije od posljednjeg pokretanja"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> rada na bateriji"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> od isključivanja s napajanja"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Punjenje"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Ekran uključen"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS uključen"</string>
    <string name="battery_stats_camera_on_label" msgid="4935637383628414968">"Kamera je uključena"</string>
    <string name="battery_stats_flashlight_on_label" msgid="4319637669889411307">"Svjetiljka je uključena"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"WiFi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Aktivan"</string>
    <string name="battery_stats_phone_signal_label" msgid="4137799310329041341">"Signal mobilne mreže"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Vrijeme aktivnosti uređaja"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Wi‑Fi na vrijeme"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Wi‑Fi na vrijeme"</string>
    <string name="advanced_battery_title" msgid="6768618303037280828">"Potrošnja baterije"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Detalji historije"</string>
    <string name="battery_details_title" msgid="6101394441569858580">"Potrošnja baterije"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Detalji o upotrebi"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Podesite potrošnju energije"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Uključeni paketi"</string>
    <string name="battery_tip_summary_title" msgid="368729969313047399">"Aplikacije rade uobičajeno"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="2198778125778121221">"Telefon ima uobičajenu potrošnju baterije u pozadini"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="1183976728682325345">"Tablet ima uobičajenu potrošnju baterije u pozadini"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="363718204492523920">"Uređaj ima uobičajenu potrošnju baterije u pozadini"</string>
    <string name="battery_tip_low_battery_title" msgid="5103420355109677385">"Nizak kapacitet baterije"</string>
    <string name="battery_tip_low_battery_summary" msgid="4702986182940709150">"Baterija ne može osigurati dobar vijek trajanja"</string>
    <string name="battery_tip_smart_battery_title" product="default" msgid="2542822112725248683">"Poboljšajte vijek trajanja baterije telefona"</string>
    <string name="battery_tip_smart_battery_title" product="tablet" msgid="6452567046912954866">"Poboljšajte vijek trajanja baterije tableta"</string>
    <string name="battery_tip_smart_battery_title" product="device" msgid="4445149029390556382">"Poboljšajte vijek trajanja baterije uređaja"</string>
    <string name="battery_tip_smart_battery_summary" msgid="2326809294592208069">"Uključite Upravitelja baterije"</string>
    <string name="battery_tip_early_heads_up_title" msgid="5788492366387119807">"Uključite Uštedu baterije"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="1639271439914224547">"Baterija bi vam se mogla isprazniti prije nego obično"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="4294083319255926811">"Uključena je Ušteda baterije"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7054036010928794364">"Neke funkcije mogu biti ograničene"</string>
    <string name="battery_tip_high_usage_title" product="default" msgid="1282187115295901930">"Koristili ste telefon više nego obično"</string>
    <string name="battery_tip_high_usage_title" product="tablet" msgid="7422137233845959351">"Koristili ste tablet više nego obično"</string>
    <string name="battery_tip_high_usage_title" product="device" msgid="5483320224273724068">"Koristili ste uređaj više nego obično"</string>
    <string name="battery_tip_high_usage_summary" msgid="5343363604280323738">"Moguće je da će se baterija isprazniti brže nego obično"</string>
    <string name="battery_tip_dialog_message" product="default" msgid="797225122502556066">"Vaš telefon je korišten više nego obično. Baterija se može istrošiti brže nego što je predviđeno.\n\nAplikacije koje najviše troše bateriju:"</string>
    <string name="battery_tip_dialog_message" product="tablet" msgid="49788591262480482">"Vaš tablet je korišten više nego obično. Baterija se može istrošiti brže nego što je predviđeno.\n\nAplikacije koje najviše troše bateriju:"</string>
    <string name="battery_tip_dialog_message" product="device" msgid="7959652003221931962">"Vaš uređaj je korišten više nego obično. Baterija se može istrošiti brže nego što je predviđeno.\n\nAplikacije koje najviše troše bateriju:"</string>
    <string name="battery_tip_dialog_message_footer" msgid="2560019187096011163">"Uključuje aktivnost u pozadini s velikom potrošnjom baterije"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="467228882789275512">
      <item quantity="one">Ograničite %1$d aplikaciju</item>
      <item quantity="few">Ograničite %1$d aplikacije</item>
      <item quantity="other">Ograničite %1$d aplikacija</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_title" formatted="false" msgid="2996094393897875408">
      <item quantity="one">%2$d aplikacija je nedavno ograničena</item>
      <item quantity="few">%2$d aplikacije su nedavno ograničene</item>
      <item quantity="other">%2$d aplikacija je nedavno ograničeno</item>
    </plurals>
    <plurals name="battery_tip_restrict_summary" formatted="false" msgid="5768962491638423979">
      <item quantity="one">%2$d aplikacija ima visoku potrošnju baterije u pozadini</item>
      <item quantity="few">%2$d aplikacije imaju visoku potrošnju baterije u pozadini</item>
      <item quantity="other">%2$d aplikacija ima visoku potrošnju baterije u pozadini</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="1040488674178753191">
      <item quantity="one">Ove aplikacije ne mogu raditi u pozadini</item>
      <item quantity="few">Ove aplikacije ne mogu raditi u pozadini</item>
      <item quantity="other">Ove aplikacije ne mogu raditi u pozadini</item>
    </plurals>
    <plurals name="battery_tip_restrict_app_dialog_title" formatted="false" msgid="8130618585820429591">
      <item quantity="one">Ograničiti %1$d aplikaciju?</item>
      <item quantity="few">Ograničiti %1$d aplikacije?</item>
      <item quantity="other">Ograničiti %1$d aplikacija?</item>
    </plurals>
    <string name="battery_tip_restrict_app_dialog_message" msgid="7271391929137806299">"Da uštedite bateriju, spriječite aplikaciju <xliff:g id="APP">%1$s</xliff:g> da koristi bateriju u pozadini. Moguće je da ta aplikacija neće raditi pravilno i da će obavještenja kasniti."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="3175700359860699627">"Da uštedite bateriju, spriječite ove aplikacije da koriste bateriju u pozadini. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti.\n\nAplikacije:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="582641081128076191">"Da uštedite bateriju, spriječite ove aplikacije da koriste bateriju u pozadini. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti.\n\nAplikacije:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="8291115820018013353">"Ograniči"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="4321334634106715162">"Želite ukloniti ograničenje?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="6537761705584610231">"Ova aplikacija će moći koristiti bateriju u pozadini. Vaša baterija bi se mogla isprazniti prije nego što očekujete."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="6022058431218137646">"Ukloni"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="3058235875830858902">"Otkaži"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="4628448253185085796">"Vaše aplikacije troše bateriju uobičajenom brzinom. Ako prebrzo troše bateriju, telefon će predložiti radnje koje možete preduzeti.\n\nUvijek možete uključiti Uštedu baterije ako je baterija skoro prazna."</string>
    <string name="battery_tip_dialog_summary_message" product="tablet" msgid="8327950887399420971">"Vaše aplikacije troše bateriju uobičajenom brzinom. Ako prebrzo troše bateriju, tablet će predložiti radnje koje možete preduzeti.\n\nUvijek možete uključiti Uštedu baterije ako je baterija skoro prazna."</string>
    <string name="battery_tip_dialog_summary_message" product="device" msgid="6753742263807939789">"Vaše aplikacije troše bateriju uobičajenom brzinom. Ako prebrzo troše bateriju, uređaj će predložiti radnje koje možete preduzeti.\n\nUvijek možete uključiti Uštedu baterije ako je baterija skoro prazna."</string>
    <string name="smart_battery_manager_title" msgid="870632749556793417">"Upravitelj baterije"</string>
    <string name="smart_battery_title" msgid="6218785691872466076">"Automatsko upravljanje aplikacijama"</string>
    <string name="smart_battery_summary" msgid="1339184602000004058">"Ograničite upotrebu baterije za aplikacije koje ne koristite često"</string>
    <string name="smart_battery_footer" product="default" msgid="5555604955956219544">"Kada Upravitelj baterije otkrije da aplikacije troše bateriju, imat ćete opciju da na te aplikacije postavite ograničenje. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti."</string>
    <string name="smart_battery_footer" product="tablet" msgid="5555604955956219544">"Kada Upravitelj baterije otkrije da aplikacije troše bateriju, imat ćete opciju da na te aplikacije postavite ograničenje. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti."</string>
    <string name="smart_battery_footer" product="device" msgid="5555604955956219544">"Kada Upravitelj baterije otkrije da aplikacije troše bateriju, imat ćete opciju da na te aplikacije postavite ograničenje. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti."</string>
    <string name="restricted_app_title" msgid="8982477293044330653">"Ograničene aplikacije"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="7355687633914223530">
      <item quantity="one">Ograničavanje potrošnje baterije za %1$d aplikaciju</item>
      <item quantity="few">Ograničavanje potrošnje baterije za %1$d aplikacije</item>
      <item quantity="other">Ograničavanje potrošnje baterije za %1$d aplikacija</item>
    </plurals>
    <string name="restricted_app_time_summary" msgid="6983512391277778623">"Ograničeno <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="6739863162364046859">"Ove aplikacije koriste bateriju u pozadini. Moguće je da aplikacije s ograničenjem neće raditi pravilno i da će obavještenja kasniti."</string>
    <string name="battery_auto_restriction_title" msgid="6553271897488963709">"Upotreba Upravitelja baterije"</string>
    <string name="battery_auto_restriction_summary" msgid="8561335400991281062">"Otkrij kada aplikacije troše bateriju"</string>
    <string name="battery_manager_on" msgid="8643310865054362396">"Uključeno / Otkrivanje kada aplikacije troše bateriju"</string>
    <string name="battery_manager_off" msgid="5473135235710343576">"Isključeno"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="1026141135861471129">
      <item quantity="one">Ograničena je %1$d aplikacija</item>
      <item quantity="few">Ograničene su %1$d aplikacije</item>
      <item quantity="other">Ograničeno je %1$d aplikacija</item>
    </plurals>
    <string name="battery_header_title_alternate" msgid="1766047545950757380">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="dialog_stop_title" msgid="6395127715596746479">"Želite zaustaviti aplikaciju?"</string>
    <string name="dialog_stop_message" product="default" msgid="4006631636646776488">"Vaš telefon ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno drži vaš telefon aktivnim.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju.\n\nAko se problem ne riješi, možda ćete trebati deinstalirati aplikaciju da poboljšate rad baterije."</string>
    <string name="dialog_stop_message" product="tablet" msgid="2369957934555162428">"Vaš tablet ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno drži vaš tablet aktivnim.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju.\n\nAko se problem ne riješi, možda ćete trebati deinstalirati aplikaciju da poboljšate rad baterije."</string>
    <string name="dialog_stop_message" product="device" msgid="6195430620406365292">"Vaš uređaj ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno drži vaš uređaj aktivnim.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju.\n\nAko se problem ne riješi, možda ćete trebati deinstalirati aplikaciju da poboljšate rad baterije."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="default" msgid="1638726742782558262">"Vaš telefon ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP_0">%1$s</xliff:g> stalno podiže telefon iz stanja mirovanja.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g>.\n\nAko se problem ne riješi, možda ćete trebati deinstalirati aplikaciju da poboljšate rad baterije."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="tablet" msgid="8771690983566539742">"Vaš tablet ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP_0">%1$s</xliff:g> stalno podiže tablet iz stanja mirovanja.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g>.\n\nAko se problem ne riješi, možda ćete trebati deinstalirati aplikaciju da poboljšate rad baterije."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="device" msgid="2854944538238649520">"Vaš uređaj ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP_0">%1$s</xliff:g> stalno podiže uređaj iz stanja mirovanja.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g>.\n\nAko se problem ne riješi, možda ćete trebati deinstalirati aplikaciju da poboljšate rad baterije."</string>
    <string name="dialog_stop_ok" msgid="2319777211264004900">"Zaustavi aplikaciju"</string>
    <string name="dialog_background_check_title" msgid="6936542136153283692">"Želite li isključiti korištenje u pozadini i zaustaviti aplikaciju?"</string>
    <string name="dialog_background_check_message" product="default" msgid="4045827746349279563">"Vaš telefon ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP_0">%1$s</xliff:g> stalno podiže vaš telefon iz stanja mirovanja.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g> i spriječiti njen rad u pozadini."</string>
    <string name="dialog_background_check_message" product="tablet" msgid="8348214419901788270">"Vaš tablet ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP_0">%1$s</xliff:g> stalno podiže vaš tablet iz stanja mirovanja.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g> i spriječiti njen rad u pozadini."</string>
    <string name="dialog_background_check_message" product="device" msgid="5847977433118915863">"Vaš uređaj ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP_0">%1$s</xliff:g> stalno podiže vaš uređaj iz stanja mirovanja.\n\nDa pokušate riješiti ovaj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g> i spriječiti njen rad u pozadini."</string>
    <string name="dialog_background_check_ok" msgid="412876934682899659">"Isključi"</string>
    <string name="dialog_location_title" msgid="5888917530725874727">"Želite li isključiti uslugu lokacije?"</string>
    <string name="dialog_location_message" product="default" msgid="7774807745601479888">"Vaš telefon ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno traži vašu lokaciju kada je ne koristite.\n\nDa pokušate riješiti ovaj problem, možete isključiti lokaciju za ovu aplikaciju."</string>
    <string name="dialog_location_message" product="tablet" msgid="118745801732181618">"Vaš tablet ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno traži vašu lokaciju kada je ne koristite.\n\nDa pokušate riješiti ovaj problem, možete isključiti lokaciju za ovu aplikaciju."</string>
    <string name="dialog_location_message" product="device" msgid="6783678153382298295">"Vaš uređaj ne može normalno upravljati baterijom jer aplikacija <xliff:g id="APP">%1$s</xliff:g> stalno traži vašu lokaciju kada je ne koristite.\n\nDa pokušate riješiti ovaj problem, možete isključiti lokaciju za ovu aplikaciju."</string>
    <string name="dialog_location_ok" msgid="4572391197601313986">"Isključi"</string>
    <string name="power_screen" msgid="3023346080675904613">"Ekran"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Svjetiljka"</string>
    <string name="power_camera" msgid="4976286950934622605">"Fotoaparat"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi‑Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="3392999761958982492">"Mobilna mreža u stanju mirovanja"</string>
    <string name="power_phone" msgid="5392641106474567277">"Glasovni pozivi"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tablet u stanju mirovanja"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Telefon u stanju mirovanja"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Razno"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Prekoračenje izračuna"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"Ukupno CPU"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"CPU u prvom planu"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Drži aktivnim"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Funkcioniranje WiFi-ja"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tablet"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefon"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Poslani mobilni paketi"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Primljeni mobilni paketi"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Mobilni radio aktivan"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"WiFi paketi koji se šalju"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Primljeni WiFi paketi"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Zvuk"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Video"</string>
    <string name="usage_type_camera" msgid="8299433109956769757">"Kamera"</string>
    <string name="usage_type_flashlight" msgid="1516392356962208230">"Svjetiljka"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Vrijeme rada"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Vrijeme bez signala"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Ukupni kapacitet baterije"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Izračunata potrošnja energije"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Uočena potrošnja energije"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Prisilno zaustavi"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Informacije o aplikaciji"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Postavke aplikacije"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Postavke ekrana"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Postavke za WiFi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Bluetooth postavke"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Korištenje baterije za govorne pozive"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Korištenje baterije kada je tablet neaktivan"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Potrošnja baterije kada je telefon u stanju pripravnosti"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Potrošnja baterije za mobilni radio"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Prebacite se na način rada u avionu kako biste štedili napajanje na područjima u kojima nema pokrivenosti mobilnom mrežom"</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Potrošnja baterije upotrebom svjetiljke"</string>
    <string name="battery_desc_camera" msgid="7375389919760613499">"Potrošnja baterije upotrebom kamere"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Potrošnja baterije na prikaz i pozadinsko osvjetljenje"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Smanjite osvjetljenje ekrana i/ili trajanje perioda do isključivanja ekrana"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Korištenje baterije za WiFi"</string>
    <string name="battery_sugg_wifi" msgid="7776093125855397043">"Isključite WiFi kada se ne koristi ili kada nije dostupan"</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Potrošnja baterije za Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="4565141162650835009">"Isključite Bluetooth kada se ne koristi"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Pokušajte se povezati na drugi Bluetooth uređaj"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Potrošnja baterije za aplikaciju"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Zaustavi ili deinstaliraj aplikaciju"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Odaberite režim uštede baterije"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Aplikacija može sadržavati postavke da smanji potrošnju baterije"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Baterija koju troši korisnik"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Nedefinisana potrošnja energije"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"Potrošnja baterije je približna vrijednost potrošnje energije te ne uključuje svaki izvor potrošnje baterije. Nedefinisana potrošnja je razlika između izračunate približne potrošnje energije i stvarne potrošnje koja se uočava na bateriji."</string>
    <string name="battery_desc_overcounted" msgid="5481865509489228603">"Prekoračenje potrošnje energije"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="2690821851327075443">"Korišteno <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="2964359540508103032">"Aktivna već <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="6537658662149713585">"Korištenje ekrana <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="1135316757755282999">"Aplikacija <xliff:g id="APP">%2$s</xliff:g> koristi <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="2093409063297375436">"<xliff:g id="PERCENT">%1$s</xliff:g> ukupne baterije"</string>
    <string name="battery_detail_since_full_charge" msgid="7515347842046955855">"Pregled od posljednje potpune napunjenosti"</string>
    <string name="battery_last_full_charge" msgid="7151251641099019361">"Posljednja potpuna napunjenost"</string>
    <string name="battery_full_charge_last" msgid="8892335687734288031">"Potpuna napunjenost traje"</string>
    <string name="battery_footer_summary" msgid="67169726550144016">"Podaci o potrošnji baterije su približni i mogu se promijeniti u zavisnosti od korištenja"</string>
    <string name="battery_detail_foreground" msgid="3350401514602032183">"Dok se aktivno koristi"</string>
    <string name="battery_detail_background" msgid="1929644393553768999">"Dok je u pozadini"</string>
    <string name="battery_detail_power_usage" msgid="6485766868610469101">"Potrošnja baterije"</string>
    <string name="battery_detail_info_title" msgid="8227822131405620369">"Od potpune napunjenosti"</string>
    <string name="battery_detail_manage_title" msgid="9094314252105828014">"Upravljanje korištenjem baterije"</string>
    <string name="advanced_battery_graph_subtext" msgid="5621073891377915877">"Procjena preostalog trajanja baterije zasnovana je na korištenju uređaja"</string>
    <string name="estimated_time_left" msgid="7514194472683370877">"Procjena preostalog vremena"</string>
    <string name="estimated_charging_time_left" msgid="5614442409326164691">"Do potpune napunjenosti"</string>
    <string name="estimated_time_description" msgid="8760210909000037089">"Procjena se može mijenjati u zavisnosti od korištenja"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> od isključivanja s napajanja"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Tokom posljednjeg isključivanja s napajanja <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Ukupno korištenje"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Osvježi"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"Android OS"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Server za medijske sadržaje"</string>
    <string name="process_dex2oat_label" msgid="2592408651060518226">"Optimizacija aplikacija"</string>
    <string name="battery_saver" msgid="8172485772238572153">"Ušteda baterije"</string>
    <string name="battery_saver_auto_title" msgid="8368709389419695611">"Automatski uključi"</string>
    <string name="battery_saver_auto_no_schedule" msgid="632243833320671052">"Nema rasporeda"</string>
    <string name="battery_saver_auto_routine" msgid="8076053160450346731">"Na osnovu vaše rutine"</string>
    <string name="battery_saver_auto_percentage" msgid="9000542338151528905">"Na osnovu postotka"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3030089882678228374">"Ušteda baterije će se uključiti ako je vjerovatno da će se baterija istrošiti prije sljedećeg uobičajenog punjenja"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="3653601117764171846">"Uključit će se na <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="6000660866895036589">"Postavite raspored"</string>
    <!-- no translation found for battery_saver_turn_on_summary (5552800757174173459) -->
    <skip />
    <string name="battery_saver_sticky_title_new" msgid="613272902035943099">"Isključi kada se potpuno napuni"</string>
    <string name="battery_saver_sticky_description_new" product="default" msgid="6659545534053937371">"Ušteda baterije se isključuje kada je baterija telefona napunjena <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="tablet" msgid="6537930800784858686">"Ušteda baterije se isključuje kada je baterija tableta napunjena <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="device" msgid="8309483774864505603">"Ušteda baterije se isključuje kada je baterija uređaja napunjena <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3795833548145424276) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="1138980155985636295">"Uključi"</string>
    <string name="battery_saver_master_switch_title" msgid="622539414546588436">"Koristi Uštedu baterije"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Automatsko uključivanje"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Nikad"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="8665950426992057191">"na <xliff:g id="PERCENT">%1$s</xliff:g> baterije"</string>
    <string name="battery_percentage" msgid="723291197508049369">"Postotak napunjenosti baterije"</string>
    <string name="battery_percentage_description" msgid="8511658577507384014">"Prikaz postotka napunjenosti baterije na statusnoj traci"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Statistika procesa"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Geeky statistike o pokrenutim procesima"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Iskorištena memorija"</string>
    <string name="process_stats_total_duration" msgid="7417201400853728029">"<xliff:g id="USEDRAM">%1$s</xliff:g> od <xliff:g id="TOTALRAM">%2$s</xliff:g> korišteno tokom zadnjih <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="6522457033380025618">"<xliff:g id="PERCENT">%1$s</xliff:g> RAM-a korišteno tokom <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"Pozadina"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"Prvi plan"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"Keširano"</string>
    <string name="process_stats_os_label" msgid="4813434110442733392">"Android OS"</string>
    <string name="process_stats_os_native" msgid="5322428494231768472">"Izvorni"</string>
    <string name="process_stats_os_kernel" msgid="1938523592369780924">"Kernel"</string>
    <string name="process_stats_os_zram" msgid="677138324651671575">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="6432533624875078233">"Keš-memorije"</string>
    <string name="process_stats_ram_use" msgid="976912589127397307">"Upotreba RAM-a"</string>
    <string name="process_stats_bg_ram_use" msgid="5398191511030462404">"Korištenje RAM-a (u pozadini)"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Vrijeme izvršavanja"</string>
    <string name="processes_subtitle" msgid="6827502409379462438">"Procesi"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Usluge"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Trajanje"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Detalji o memoriji"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 sata"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 sati"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 sati"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 dan"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Prikaži sistemske procese"</string>
    <string name="menu_hide_system" msgid="4106826741703745733">"Sakrij sistemske procese"</string>
    <string name="menu_show_percentage" msgid="4717204046118199806">"Prikaži postotke"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Koristi Uss"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Tip statističkih podataka"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"Pozadina"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"Prvi plan"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"Keširano"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Glasovni unos i izlaz"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Postavke glasovnog unosa i izlaza"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Glasovno pretraživanje"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Android tastatura"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Podešavanja govornog unosa"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Govorni unos"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Usluge govornog unosa"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Cela aktuelna reč i interakcija"</string>
    <string name="voice_recognizer_preference_summary" msgid="669880813593690527">"Jednostavno pretvaranje govora u tekst"</string>
    <string name="voice_interaction_security_warning" msgid="6378608263983737325">"Ova usluga za glasovni unos će biti u mogućnosti da obavlja uvijek uključeno praćenje glasa i da u vaše ime kontrolira aplikacije omogućene glasom. Ona dolazi iz <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g> aplikacija. Omogućiti korištenje ove usluge?"</string>
    <string name="tts_engine_preference_title" msgid="1578826947311494239">"Željeni alat"</string>
    <string name="tts_engine_settings_title" msgid="6886964122861384818">"Postavke programa"</string>
    <string name="tts_sliders_title" msgid="992059150784095263">"Brzina govora i visina glasa"</string>
    <string name="tts_engine_section_title" msgid="6289240207677024034">"Program"</string>
    <string name="tts_install_voice_title" msgid="6275828614052514320">"Glasovi"</string>
    <string name="tts_spoken_language" msgid="5542499183472504027">"Jezik govora"</string>
    <string name="tts_install_voices_title" msgid="8808823756936022641">"Instalirajte Glasove"</string>
    <string name="tts_install_voices_text" msgid="5292606786380069134">"Nastavite na aplikaciju <xliff:g id="TTS_APP_NAME">%s</xliff:g> da instalirate glasove"</string>
    <string name="tts_install_voices_open" msgid="667467793360277465">"Otvori aplikaciju"</string>
    <string name="tts_install_voices_cancel" msgid="4711492804851107459">"Otkaži"</string>
    <string name="tts_reset" msgid="2661752909256313270">"Vrati na zadano"</string>
    <string name="tts_play" msgid="2628469503798633884">"Pokreni"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Pohrana akreditiva"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Instaliranje iz pohrane"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Instaliraj sa SD kartice"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Instaliranje certifikata iz pohrane"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Instaliraj certifikate sa SD kartice"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Brisanje akreditiva"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Uklanjanje svih certifikata"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Pouzdani akreditivi"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Prikaz pouzdanih CA certifikata"</string>
    <string name="user_credentials" msgid="3719013347787187083">"Korisnički akreditivi"</string>
    <string name="user_credentials_summary" msgid="7271228342106080167">"Prikaz i izmjena pohranjenih akreditiva"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Napredno"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Vrsta pohrane"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Sa hardverskom podlogom"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Samo softverski"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Akreditivi nisu dostupni za ovog korisnika"</string>
    <string name="credential_for_vpn_and_apps" msgid="4168197158768443365">"Instalirani za VPN i aplikacije"</string>
    <string name="credential_for_wifi" msgid="6228425986551591864">"Instalirani za WiFi mrežu"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Ukloniti sav sadržaj?"</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Pohrana akreditiva je izbrisana."</string>
    <string name="credentials_not_erased" msgid="7685932772284216097">"Nije uspjelo bris. memorije vjerodaj."</string>
    <string name="usage_access_title" msgid="332333405495457839">"Apl. s pristupom pod. o korišt."</string>
    <string name="emergency_tone_title" msgid="254495218194925271">"Signal za hitne pozive"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Postavi ponašanje prilikom upućivanja poziva za hitne situacije"</string>
    <string name="privacy_settings_title" msgid="2978878794187459190">"Izrada sigurnosnih kopija"</string>
    <string name="backup_summary_state_on" msgid="6407084627816231202">"Uključeno"</string>
    <string name="backup_summary_state_off" msgid="7388321532624105594">"Isključeno"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Sigurnosna kopija i vraćanje"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Lični podaci"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Izrada sigurnosnih kopija podataka"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Pravite sigurnosne kopije podataka aplikacija, lozinki za WiFi te drugih postavki na Google serverima"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Račun za rezervnu kopiju"</string>
    <string name="backup_data_management_title" msgid="4059093462647090064">"Upravljajte računom za sigurnosne kopije"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Uvrstite podatke aplikacije"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Automatsko vraćanje"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Prilikom ponovnog instaliranja aplikacije, vraća sigurnosne kopije postavki i podataka"</string>
    <string name="backup_inactive_title" msgid="685838037986644604">"Usluga za izradu sigurnosne kopije nije aktivna"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Nijedan račun trenutno ne pravi sigurnosne kopije podataka"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Želite li prestati sa izradom sigurnosnih kopija lozinki za WiFi, oznaka, drugih postavki te podataka aplikacija i izbrisati sve kopije sa Google servera?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="694766389396659626">"Prestani da praviš sigurnosne kopije podataka (npr. lozinke za WiFi i istorija poziva) i podataka aplikacije (npr. postavke i fajlovi koje pohranjuju aplikacije), i izbriši sve kopije na udaljenim serverima?"</string>
    <string name="fullbackup_data_summary" msgid="960850365007767734">"Daljinski pokrenite automatsku izradu sigurnosnih kopija podataka na uređaju (npr. WiFi lozinki i historije poziva) i podataka iz aplikacija (npr. postavki i fajlova koje pohranjuju aplikacije).\n\nKada uključite automatsku izradu sigurnosnih kopija, podaci iz uređaja i aplikacija se periodično pohranjuju daljinski. Podaci iz aplikacije mogu biti bilo koji podaci koje je aplikacija sačuvala (na osnovu programerskih postavki), uključujući i potencijalno osjetljive podatke, kao što su kontakti, poruke i fotografije."</string>
    <string name="device_admin_settings_title" msgid="4960761799560705902">"Postavke administratora uređaja"</string>
    <string name="active_device_admin_msg" msgid="578748451637360192">"Aplikacija administratora uređaja"</string>
    <string name="remove_device_admin" msgid="9207368982033308173">"Deaktiviraj ovu aplikaciju administratora uređaja"</string>
    <string name="uninstall_device_admin" msgid="271120195128542165">"Deinstaliraj aplikaciju"</string>
    <string name="remove_and_uninstall_device_admin" msgid="3837625952436169878">"Deaktiviraj i deinstaliraj"</string>
    <string name="select_device_admin_msg" msgid="7347389359013278077">"Aplikacije administratora uređaja"</string>
    <string name="no_device_admins" msgid="4846602835339095768">"Nema dostupnih aplikacija administratora uređaja"</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Lični"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Work"</string>
    <string name="sms_access_restriction_enabled" msgid="7054488078710530278">"Ograniči pristup SMS-u i zapisniku poziva"</string>
    <string name="sms_access_restriction_enabled_summary" msgid="6851339654677842328">"Samo zadane aplikacije za telefon i poruke imaju odobrenja za SMS i zapisnike poziva"</string>
    <string name="device_identifier_access_restrictions_title" msgid="263947581571420743">"Onemogući ograničenja za identifikator uređaja"</string>
    <string name="device_identifier_access_restrictions_summary" msgid="1716838570236517731">"Onemogućite nova ograničenja pristupa za identifikatore uređaja"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Nema dostupnih pouzdanih agenata"</string>
    <string name="add_device_admin_msg" msgid="1501847129819382149">"Aktivirati aplikaciju administratora uređaja?"</string>
    <string name="add_device_admin" msgid="4192055385312215731">"Aktiviraj aplikaciju administratora uređaja"</string>
    <string name="device_admin_add_title" msgid="3140663753671809044">"Administrator uređaja"</string>
    <string name="device_admin_warning" msgid="7482834776510188134">"Ako aktivirate ovu aplikaciju administratora, omogućit ćete aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> da izvršava sljedeće operacije:"</string>
    <string name="device_admin_status" msgid="7234814785374977990">"Ova aplikacija administratora je aktivna i omogućava aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> da izvršava sljedeće operacije:"</string>
    <string name="profile_owner_add_title" msgid="6249331160676175009">"Aktivirati Upravitelj profila?"</string>
    <string name="adding_profile_owner_warning" msgid="1354474524852805802">"Ako nastavite, vašim korisnikom će upravljati vaš administrator koji će, osim vaših ličnih podataka, moći pohranjivati i povezane podatke.\n\nVaš administrator može pratiti i upravljati postavkama, pristupom, aplikacijama i podacima koji su povezani s ovim korisnikom, uključujući aktivnost na mreži i informacije o lokaciji vašeg uređaja."</string>
    <string name="admin_disabled_other_options" msgid="7712694507069054530">"Administrator je onemogućio ostale opcije"</string>
    <string name="admin_more_details" msgid="7901420667346456102">"Više detalja"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Dnevnik obavještenja"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Melodija zvona telefona i vibracija"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Detalji o mreži"</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Sinhronizacija omogućena"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Sinhroniziranje onemogućeno"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Sinhronizuje se"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Greška pri sinhroniziranju."</string>
    <string name="sync_failed" msgid="1696499856374109647">"Sinhroniziranje nije uspjelo"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sinhroniziranje aktivno"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sinhroniziraj"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Trenutno ima problema sa sinhroniziranjem. Ubrzo će opet raditi."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Dodaj račun"</string>
    <string name="managed_profile_not_available_label" msgid="852263300911325904">"Radni profil još uvijek nije dostupan"</string>
    <string name="work_mode_label" msgid="7157582467956920750">"Radni profil"</string>
    <string name="work_mode_on_summary" msgid="3628349169847990263">"Upravlja vaša organizacija"</string>
    <string name="work_mode_off_summary" msgid="2657138190560082508">"Aplikacije i obavještenja su isključeni"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Ukloni radni profil"</string>
    <string name="background_data" msgid="5779592891375473817">"Podaci u pozadini"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Aplikacije mogu sinhronizirati, slati i primati podatke u bilo koje vrijeme"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Onemogućiti podatke u pozadini?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Onemogućavanjem prijenosa podataka u pozadini produžava se trajanje baterije i smanjuje korištenje podataka. Neke aplikacije mogu i dalje koristiti vezu za prijenos podataka u pozadini."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Aut. sinhronizir. podat. aplikacija"</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Sinhroniziranje UKLJUČENO"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Sinhronizacija ISKLJUČENA"</string>
    <string name="sync_error" msgid="5060969083117872149">"Greška u sinhroniziranju"</string>
    <string name="last_synced" msgid="4242919465367022234">"Posljednje sinhroniziranje: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Sinhroniziraj sada…"</string>
    <string name="settings_backup" msgid="2274732978260797031">"Napravi rezervnu kopiju postavki"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Napravi rezervnu kopiju mojih postavki"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Sinhroniziraj sada"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Otkaži sinhroniziranje"</string>
    <string name="sync_one_time_sync" msgid="3733796114909082260">"Dodirnite da sinhronizirate odmah<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Kalendar"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Kontakti"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Dobro došli u Google sync!"</font>" \nGoogle pristup sinhroniziranju podataka kako bi se omogućio pristup vašim kontaktima, obavezama i drugim stavkama gdje god da se nalazite."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Postavke sinhroniziranja aplikacija"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Podaci i sinhroniziranje"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Promijenite lozinku"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Postavke računa"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Ukloni račun"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Dodajte račun"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Ukloniti račun?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Uklanjanjem ovog računa će se izbrisati sve njegove poruke, kontakti i ostali podaci s tableta!"</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Uklanjanjem ovog računa će se izbrisati sve njegove poruke, kontakti i ostali podaci s telefona!"</string>
    <string name="really_remove_account_message" product="device" msgid="7507474724882080166">"Uklanjanjem ovog računa izbrisat ćete sve njegove poruke, kontakte i druge podatke s uređaja!"</string>
    <string name="remove_account_failed" msgid="3901397272647112455">"Vaš administrator ne dopušta ovu promjenu"</string>
    <string name="cant_sync_dialog_title" msgid="2777238588398046285">"Nije moguće ručno sinhronizovati"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Sinhroniziranje za ovu stavku trenutno nije moguće. Da biste promijenili ovu postavku, privremeno uključite podatke u pozadini i automatsko sinhroniziranje."</string>
    <string name="enter_password" msgid="8035706727471334122">"Da biste pokrenuli Android, unesite lozinku"</string>
    <string name="enter_pin" msgid="5305333588093263790">"Da biste pokrenuli Android, unesite PIN"</string>
    <string name="enter_pattern" msgid="4187435713036808566">"Da biste pokrenuli Android, nacrtajte svoj obrazac"</string>
    <string name="cryptkeeper_wrong_pattern" msgid="8423835922362956999">"Pogrešan obrazac"</string>
    <string name="cryptkeeper_wrong_password" msgid="5200857195368904047">"Pogrešna lozinka"</string>
    <string name="cryptkeeper_wrong_pin" msgid="755720788765259382">"Pogrešan PIN"</string>
    <string name="checking_decryption" msgid="8287458611802609493">"Provjera u toku..."</string>
    <string name="starting_android" msgid="4001324195902252681">"Pokretanje Androida…"</string>
    <string name="delete" msgid="4219243412325163003">"Izbriši"</string>
    <string name="misc_files" msgid="6720680815969643497">"Razni fajlovi"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"odabrano <xliff:g id="NUMBER">%1$d</xliff:g> od <xliff:g id="TOTAL">%2$d</xliff:g>"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> od <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Označi sve"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Prijenos podataka"</string>
    <string name="data_usage_app_summary_title" msgid="5571051159374290375">"Prijenos podataka na mobilnoj mreži i WiFi"</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"Obračun podataka operatera može se razlikovati od obračuna vašeg uređaja."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Korištenje aplikacija"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"INFORMACIJE O APLIKACIJI"</string>
    <string name="data_usage_cellular_data" msgid="9168928285122125137">"Prijenos podataka na mobilnoj mreži"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Postavljanje ograničenja potrošnje"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Ciklus prijenosa podataka"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Korištenje aplikacije"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Roming podataka"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Ograniči podatke u pozadini"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Dopusti pozadinske podatke"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Odvojeno korišt. 4G veze"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Prikaži WiFi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Sakrij WiFi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Prikaži korištenje Etherneta"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Sakrij korištenje podataka putem Etherneta"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Mrežna ograničenja"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Automatsko sinhroniziranje podataka"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"SIM kartice"</string>
    <string name="data_usage_cellular_data_summary" msgid="8413357481361268285">"Pauzirano na ograničenju"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Automatski sinhroniziraj podatke"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Automatska sinhronizacija ličnih podataka"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Automatska sinhronizacija podataka za posao"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Promijeni ciklus…"</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Dan u mjesecu za poništavanje ciklusa prijenosa podataka:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"Nijedna apl. nije koristila pod. u ovom periodu."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Prvi plan"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Pozadina"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"ograničeno"</string>
    <string name="data_usage_disable_mobile" msgid="8656552431969276305">"Isključiti prijenos podataka na mobilnoj mreži?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Ograničenje za mobilne podatke"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Postavi ograničenje za 4G podatke"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Ograničenje 2G-3G podataka"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Ograniči WiFi podatke"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi‑Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="454140350007299045">"Mobilni"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="5588685410495019866">"Mobilni uređaj"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Nema"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"Mobilni podaci"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"2G-3G podaci"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"4G podaci"</string>
    <string name="data_roaming_enable_mobile" msgid="1523331545457578362">"Roming"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Prvi plan:"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"Pozadina:"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Postavke aplikacije"</string>
    <string name="data_usage_app_restrict_background" msgid="7359227831562303223">"Pozadinski podaci"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="5853552187570622572">"Omogućite prijenos podataka na mobilnoj mreži u pozadini"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"Za ograničenje poz. podat. za ovu apl. ograničite mob. podatke."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Ograničiti podatke u pozadini?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="1466689968707308512">"Zbog te značajke aplikacija koja ovisi o pozadinskim podacima može prestati raditi kada su dostupne samo mobilne mreže.\n\nU postavkama možete pronaći prikladnije kontrole prijenosa podataka."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="55012417305745608">"Ograničavanje prijenosa pozadinskih podataka moguće je samo ako ste postavili ograničenje za prijenos podataka na mobilnoj mreži."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Uklj. autom. sinhron. podataka?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"Promjene računa koje unesete na webu automatski će se kopirati na tablet.\n\nNeki računi također mogu automatski kopirati promjene s tableta na web. Google račun funkcionira na ovaj način."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="8651376294887142858">"Promjene računa koje unesete na webu automatski će se kopirati na telefon.\n\nNeki računi također mogu automatski kopirati promjene s telefona na web. Google račun funkcionira na ovaj način."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Isključiti automatsko sinhroniziranje podataka?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4025938250775413864">"Ovim će se uštedjeti na prijenosu podataka i potrošnji baterije, ali ćete morati ručno sinhronizirati svaki račun da prikupite najnovije informacije. Također, nećete primati obavještenja kada se izvrše ažuriranja."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Datum poništavanja ciklusa potrošnje"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Datum svakog mjeseca:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Postavi"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Postavite upozorenje o prijenosu podataka"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Postavite ograničenje prijenosa podataka"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Ograničavanje prijenosa podataka"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="4983487893343645667">"Vaš tablet će isključiti prijenos podataka na mobilnoj mreži nakon što dostigne ograničenje koje ste postavili.\n\nS obzirom na to da vaš telefon mjeri prijenos podataka te da obračun vašeg operatera može biti drugačiji, uzmite u obzir postavljanje umjerenog ograničenja."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3926320594049434225">"Vaš telefon će isključiti prijenos podataka na mobilnoj mreži nakon što dostigne ograničenje koje ste postavili.\n\nS obzirom na to da vaš telefon mjeri prijenos podataka te da obračun vašeg operatera može biti drugačiji, uzmite u obzir postavljanje umjerenog ograničenja."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Ograničiti podatke u pozadini?"</string>
    <string name="data_usage_restrict_background" msgid="434093644726734586">"Ako ograničite prijenos pozadinskih mobilnih podataka, neke aplikacije i usluge neće raditi ukoliko niste povezani na WiFi mrežu."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="7096707497743363380">"Ako ograničite prijenos pozadinskih mobilnih podataka, neke aplikacije i usluge neće raditi ukoliko niste povezani na WiFi mrežu.\n\nOva postavka utiče na sve korisnike registrirane na ovom tabletu."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="7910798414964288424">"Ako ograničite prijenos pozadinskih mobilnih podataka, neke aplikacije i usluge neće raditi ukoliko niste povezani na WiFi mrežu.\n\nOva postavka utiče na sve korisnike registrirane na ovom telefonu."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"upozorenje"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"ograničenje"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Uklonjene aplikacije"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Uklonjene aplikacije i korisnici"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"Primljeno <xliff:g id="RECEIVED">%1$s</xliff:g>, poslano <xliff:g id="SENT">%2$s</xliff:g>"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g>: iskorišteno otprilike <xliff:g id="TOTAL">%1$s</xliff:g>."</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="1925687342154538972">"<xliff:g id="RANGE">%2$s</xliff:g>: iskoristili ste oko <xliff:g id="TOTAL">%1$s</xliff:g> prema mjerenju tableta. Obračun operatera može biti drugačiji."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="5063981061103812900">"<xliff:g id="RANGE">%2$s</xliff:g>: iskoristili ste oko <xliff:g id="TOTAL">%1$s</xliff:g> prema mjerenju telefona. Obračun operatera može biti drugačiji."</string>
    <string name="data_usage_metered_title" msgid="7383175371006596441">"Mrežna ograničenja"</string>
    <string name="data_usage_metered_body" msgid="7655851702771342507">"Mreže s naplatom tretiraju se kao mobilne mreže kada je ograničeno korištenje podataka u pozadini. Aplikacije mogu dati upozorenje prije korištenja takvih mreža za velika preuzimanja."</string>
    <string name="data_usage_metered_mobile" msgid="5423305619126978393">"Mobilne mreže"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"WiFi mreže s naplatom"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Da odaberete mreže s naplatom, uključite WiFi."</string>
    <string name="data_usage_metered_auto" msgid="1262028400911918865">"Automatski"</string>
    <string name="data_usage_metered_yes" msgid="9217539611385225894">"S naplatom"</string>
    <string name="data_usage_metered_no" msgid="4025232961929071789">"Bez naplate"</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Obračun podataka operatera može se razlikovati od obračuna vašeg uređaja."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Poziv za hitne slučajeve"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Vrati se na poziv"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Ime"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Vrsta"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Adresa servera"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"PPP šifriranje (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"L2TP tajna"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"IPSec identifikator"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Unaprijed dijeljeni IPSec ključ"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"IPSec korisnički certifikat"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"IPSec CA certifikat"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"IPSec certifikat servera"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Prikaži napredne opcije"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Domene DNS pretraživanja"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"DNS serveri (npr. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Rute prosljeđivanja (npr. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Korisničko ime"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Lozinka"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Sačuvajte informacije o računu"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(ne koristi se)"</string>
    <string name="vpn_no_ca_cert" msgid="8776029412793353361">"(ne verifikuj server)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(primljeno od servera)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="7574518311224455825">"Ova vrsta VPN-a ne može biti stalno povezana"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="477304620899799383">"Uvijek aktivni VPN podržava samo numeričke adrese servera"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="2226648961940273294">"DNS server mora biti naveden za uvijek aktivni VPN"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3551394495620249972">"Adrese DNS servera moraju biti numeričke za uvijek aktivni VPN"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="5959352052515258208">"Unesena informacija ne podržava uvijek aktivni VPN"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Otkaži"</string>
    <string name="vpn_done" msgid="8678655203910995914">"Odbaci"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Sačuvaj"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Poveži se"</string>
    <string name="vpn_replace" msgid="5442836256121957861">"Zamijeni"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Uredite VPN profil"</string>
    <string name="vpn_forget" msgid="3684651372749415446">"Zaboravi"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Poveži se na <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="3743970132487505659">"Želite li prekinuti vezu s ovim VPN-om?"</string>
    <string name="vpn_disconnect" msgid="7426570492642111171">"Prekini vezu"</string>
    <string name="vpn_version" msgid="1939804054179766249">"Verzija <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="2232239391189465752">"Zaboravi VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="2963898301277610248">"Želite li zamijeniti postojeći VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="4009987321156037267">"Želite li postaviti uvijek uključen VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="7144543717673197102">"Kada se uključi ova postavka, nećete imati internetsku mrežu dok se VPN ne poveže"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="798121133114824006">"Vaš postojeći VPN će se zamijeniti i nećete imati internetsku vezu dok se VPN ne poveže"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="3011818750025879902">"Već ste povezani na \"uvijek uključen\" VPN. Ako se povežete na drugu mrežu, vaša postojeća VPN će biti zamijenjena, a način rada \"uvijek uključeno\" će se isključiti."</string>
    <string name="vpn_replace_vpn_message" msgid="5611635724578812860">"Već ste povezani na VPN. Ako se povežete na drugu, postojeći VPN će biti zamijenjen."</string>
    <string name="vpn_turn_on" msgid="2363136869284273872">"Uključi"</string>
    <string name="vpn_cant_connect_title" msgid="4517706987875907511">"<xliff:g id="VPN_NAME">%1$s</xliff:g> se ne može povezati"</string>
    <string name="vpn_cant_connect_message" msgid="1352832123114214283">"Ova aplikacija ne podržava uvijek aktivni VPN"</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Dodaj VPN profil"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Uredi profil"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Izbriši profil"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Uvijek aktivni VPN"</string>
    <string name="vpn_no_vpns_added" msgid="5002741367858707244">"Nema dodanih VPN-ova"</string>
    <string name="vpn_always_on_summary" msgid="2821344524094363617">"Ostanite stalno povezani na VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="592304911378771510">"Ova aplikacija ne podržava ovu funkciju"</string>
    <string name="vpn_always_on_summary_active" msgid="8800736191241875669">"Funkcija Uvijek uključeno je aktivna"</string>
    <string name="vpn_require_connection" msgid="8388183166574269666">"Blokiraj veze bez VPN-a"</string>
    <string name="vpn_require_connection_title" msgid="159053539340576331">"Treba li zahtijevati VPN vezu?"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Odaberite VPN profil s kojim će uvijek biti uspostavljena veza. Mrežni saobraćaj će biti dopušten samo kad je uspostavljena veza s tim VPN-om."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Nema"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Uvijek aktivni VPN zahtijeva IP adresu i za server i za DNS."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Nema mrežne veze. Pokušajte ponovo kasnije."</string>
    <string name="vpn_disconnected" msgid="280531508768927471">"Isključeni ste iz VPN-a"</string>
    <string name="vpn_disconnected_summary" msgid="3082851661207900606">"Ništa"</string>
    <string name="vpn_missing_cert" msgid="5357192202207234745">"Nedostaje certifikat. Pokušajte urediti profil."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Sistem"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Korisnik"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Onemogući"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Omogući"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Ukloni"</string>
    <string name="trusted_credentials_trust_label" msgid="8003264222650785429">"Povjerenje"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Omogućiti sistemski CA certifikat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Onemogućiti sistemski CA certifikat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Trajno ukloniti korisnički CA certifikat?"</string>
    <string name="credential_contains" msgid="3984922924723974084">"Ovaj unos sadrži:"</string>
    <string name="one_userkey" msgid="6034020579534914349">"jedan korisnički ključ"</string>
    <string name="one_usercrt" msgid="2150319011101639509">"jedan korisnički certifikat"</string>
    <string name="one_cacrt" msgid="6844397037970164809">"jedan CA certifikat"</string>
    <string name="n_cacrts" msgid="5979300323482053820">"%d CA certifikati"</string>
    <string name="user_credential_title" msgid="1954061209643070652">"Detalji o akreditivima"</string>
    <string name="user_credential_removed" msgid="6514189495799401838">"Uklonjeni akreditiv: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="3729607560420971841">"Nisu instalirani korisnički akreditivi"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Provjera pravopisa"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="4114555511355171248">"Provjera pravopisa za posao"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Ovdje unesite trenutnu lozinku za sigurnosnu kopiju čitavog sistema"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Ovdje unesite novu lozinku za sigurnosne kopije čitavog sistema"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Ovdje ponovo unesite novu lozinku za sigurnosnu kopiju čitavog sistema"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Postavi lozinku za sigurnosnu kopiju"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Otkaži"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Dodatna ažuriranja sistema"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Mreža može biti nadzirana"</string>
    <string name="done_button" msgid="1991471253042622230">"Gotovo"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="7145092748045794650">
      <item quantity="one"> Vjerujte certifikatu ili ga uklonite</item>
      <item quantity="few"> Vjerujte certifikatima ili ih uklonite</item>
      <item quantity="other"> Vjerujte certifikatima ili ih uklonite</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message_device_owner" formatted="false" msgid="1489335297837656666">
      <item quantity="one"> Domena <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je instalirala certifikate ovlaštenja na vaš uređaj, koji im mogu omogućiti da prati radne aktivnosti mreže, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nZa više informacija o ovim certifikatima, obratite se administratoru.</item>
      <item quantity="few"> Domene <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> su instalirale certifikate ovlaštenja na vaš uređaj, koji im mogu omogućiti da prate mrežne aktivnosti vašeg uređaja, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nZa više informacija o ovim certifikatima, obratite se administratoru.</item>
      <item quantity="other"> Domena <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je instaliralo certifikate ovlaštenja na vaš uređaj, koji im mogu omogućiti da prate mrežne aktivnosti vašeg uređaja, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nZa više informacija o ovim certifikatima, obratite se administratoru.</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message" formatted="false" msgid="30645643499556573">
      <item quantity="one"> Domena <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je instalirala certifikate ovlaštenja za vaš radni profil, koji im mogu omogućiti da prati radne aktivnosti mreže, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nZa više informacija o ovim certifikatima, obratite se administratoru.</item>
      <item quantity="few"> Domene <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> su instalirale certifikate ovlaštenja za vaš radni profil, koji im mogu omogućiti da prati radne aktivnosti mreže, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nZa više informacija o ovim certifikatima, obratite se administratoru.</item>
      <item quantity="other"> Domena <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je instaliralo certifikate ovlaštenja za vaš radni profil, koji im mogu omogućiti da prati radne aktivnosti mreže, uključujući e-poštu, aplikacije i sigurne web lokacije.\n\nZa više informacija o ovim certifikatima, obratite se administratoru.</item>
    </plurals>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"Treća strana je u stanju da prati vaše mrežne aktivnosti, uključujući e-poruke, aplikacije i sigurne web lokacije. \n\nPouzdani akreditiv instaliran na vašem uređaju to omogućava."</string>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="2426799352517325228">
      <item quantity="one">Provjerite certifikate</item>
      <item quantity="few">Provjerite certifikate</item>
      <item quantity="other">Provjerite certifikate</item>
    </plurals>
    <string name="user_settings_title" msgid="3493908927709169019">"Više korisnika"</string>
    <string name="user_settings_footer_text" product="device" msgid="5947601460660791129">"Dijelite svoj uređaj dodavanjem novih korisnika. Svaki korisnik na vašem uređaju ima lični prostor za prilagođene početne ekrane, račune, aplikacije, postavke i još mnogo toga."</string>
    <string name="user_settings_footer_text" product="tablet" msgid="2153761434649733502">"Dijelite svoj tablet tako što ćete dodati nove korisnike. Svaki korisnik na vašem tabletu ima lični prostor za prilagođene početne ekrane, račune, aplikacije, postavke i još mnogo toga."</string>
    <string name="user_settings_footer_text" product="default" msgid="2844602828189838075">"Dijelite svoj telefon tako što ćete dodati nove korisnike. Svaki korisnik na vašem telefonu ima lični prostor za prilagođene početne ekrane, račune, aplikacije, postavke i još mnogo toga."</string>
    <string name="user_list_title" msgid="7937158411137563543">"Korisnici i profili"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Dodaj korisnika ili profil"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Dodaj korisnika"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Ograničeni profil"</string>
    <string name="user_need_lock_message" msgid="5879715064416886811">"Prije nego vam se omogući kreiranje ograničenog profila, morate postaviti zaključavanje ekrana da biste zaštitili svoje aplikacije i lične podatke."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Postaviti zaključavanje"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Nije postavljeno"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Nije postavljen – Ograničeni profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="1659125858619760573">"Nije postavljen – Radni profil"</string>
    <string name="user_admin" msgid="993402590002400782">"Administrator"</string>
    <string name="user_you" msgid="1639158809315025986">"Vi (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Nadimak"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Dodaj"</string>
    <string name="user_add_max_count" msgid="5405885348463433157">"Možete dodati do <xliff:g id="USER_COUNT">%1$d</xliff:g> korisnika"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Korisnici imaju sopstvene aplikacije i sadržaj"</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Možete ograničiti pristup aplikacijama i sadržaju sa svog računa"</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Korisnik"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Ograničeni profil"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"Dodati novog korisnika?"</string>
    <string name="user_add_user_message_long" msgid="6768718238082929201">"Za dijeljenje ovog uređaja s drugima možete napraviti dodatne korisnike. Svaki korisnik ima svoj prostor koji može prilagoditi pomoću aplikacija, pozadinske slike i slično. Korisnici također mogu prilagoditi postavke uređaja kao što su WiFi koje utiču na sve ostale korisnike.\n\nKada dodate novog korisnika, ta osoba treba postaviti svoj prostor.\n\nSvaki korisnik može ažurirati aplikacije za sve ostale korisnike."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Kada dodate novog korisnika, ta osoba treba postaviti svoj prostor. \n\n Svaki korisnik može ažurirati aplikacije za sve ostale korisnike."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Postaviti korisnika sada?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"Provjerite može li osoba uzeti uređaj i postaviti svoj prostor"</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Postaviti profil sada?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Postavi"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Ne sada"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="7153048188252553320">"Samo vlasnik tableta može upravljati korisnicima."</string>
    <string name="user_cannot_manage_message" product="default" msgid="959315813089950649">"Samo vlasnik telefona može upravljati korisnicima."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Ograničeni profili ne mogu dodati račune"</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Izbrišite <xliff:g id="USER_NAME">%1$s</xliff:g> sa uređaja"</string>
    <string name="user_lockscreen_settings" msgid="4965661345247084878">"Postavke zaključavanja ekrana"</string>
    <string name="user_add_on_lockscreen_menu" msgid="9072312646546364619">"Dodavanje korisnika sa zaključanog ekrana"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Novi korisnik"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Novi profil"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Želite li izbrisati sebe?"</string>
    <string name="user_confirm_remove_title" msgid="8068422695175097315">"Izbrisati ovog korisnika?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Ukloniti ovaj profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"Ukloniti profil za Work?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="2391372805233812410">"Izgubit ćete svoj prostor i podatke sa ovog tableta. Ne možete poništiti ovu akciju."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="7943645442479360048">"Izgubit ćete svoj prostor i podatke sa ovog telefona. Ne možete poništiti ovu akciju."</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"Sve aplikacije i podaci će biti izbrisani."</string>
    <string name="work_profile_confirm_remove_message" msgid="323856589749078140">"Sve aplikacije i podaci sa ovog profila će biti izbrisani ako nastavite."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"Sve aplikacije i podaci će biti izbrisani."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Dodavanje novog korisnika…"</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Izbriši korisnika"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Izbriši"</string>
    <string name="user_guest" msgid="8475274842845401871">"Gost"</string>
    <string name="user_exit_guest_title" msgid="5613997155527410675">"Uklonite gosta"</string>
    <string name="user_exit_guest_confirm_title" msgid="3405527634738147409">"Ukloniti gosta?"</string>
    <string name="user_exit_guest_confirm_message" msgid="2194459201944413257">"Sve aplikacije i podaci iz ove sesije će biti izbrisani."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Ukloniti"</string>
    <string name="user_enable_calling" msgid="5128605672081602348">"Uključi telefonske pozive"</string>
    <string name="user_enable_calling_sms" msgid="9172507088023097063">"Uključivanje telefonskih poziva i SMS-ova"</string>
    <string name="user_remove_user" msgid="3612979309028881318">"Brisanje korisnika"</string>
    <string name="user_enable_calling_confirm_title" msgid="4315789475268695378">"Uključiti telefonske pozive?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"Historija poziva će se dijeliti s ovim korisnikom."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="7243308401401932681">"Uključiti telefonske pozive i SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="4025082715546544967">"Historija poziva i SMS-ova će se dijeliti s ovim korisnikom."</string>
    <string name="emergency_info_title" msgid="208607506217060337">"Informacije za hitne slučajeve"</string>
    <string name="emergency_info_summary" msgid="5062945162967838521">"Informacije i kontakti za korisnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Odobrenja za aplikaciju i sadržaj"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Aplikacije s ograničenjima"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Proširi postavke za aplikaciju"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Dodirni i plati"</string>
    <string name="nfc_payment_how_it_works" msgid="3028822263837896720">"Način funkcioniranja"</string>
    <string name="nfc_payment_no_apps" msgid="5477904979148086424">"Plaćajte telefonom u trgovinama"</string>
    <string name="nfc_payment_default" msgid="8648420259219150395">"Zadana aplikacija za plaćanje"</string>
    <string name="nfc_payment_default_not_set" msgid="7485060884228447765">"Nije postavljeno"</string>
    <string name="nfc_payment_app_and_desc" msgid="7942415346564794258">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="3234730182120288495">"Koristiti zadanu aplikaciju"</string>
    <string name="nfc_payment_favor_default" msgid="5743781166099608372">"Uvijek"</string>
    <string name="nfc_payment_favor_open" msgid="1923314062109977944">"Osim kada je otvorena druga aplikacija za plaćanje"</string>
    <string name="nfc_payment_pay_with" msgid="7524904024378144072">"Na terminalu \"Dodirni i plati\" plaćajte pomoću:"</string>
    <string name="nfc_how_it_works_title" msgid="1984068457698797207">"Plaćanje na terminalu"</string>
    <string name="nfc_how_it_works_content" msgid="4749007806393224934">"Postavite aplikaciju za plaćanje, zatim jednostavno prislonite poleđinu svog telefona uz bilo koji terminal označen simbolom beskontaktne komunikacije."</string>
    <string name="nfc_how_it_works_got_it" msgid="259653300203217402">"Razumijem"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Više..."</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Želite li da ga postavite kao željeni izbor?"</string>
    <string name="nfc_payment_set_default" msgid="8532426406310833489">"Želite li uvijek koristiti <xliff:g id="APP">%1$s</xliff:g> kada se koristi usluga Dodirni i plati?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="6993301165940432743">"Uvijek koristiti <xliff:g id="APP_0">%1$s</xliff:g> umjesto <xliff:g id="APP_1">%2$s</xliff:g> za Dodirni i plati?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Ograničenja"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Ukloni ograničenja"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Promijeni PIN"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Prikaži obavještenja"</string>
    <string name="help_label" msgid="6886837949306318591">"Pomoć i pov. inform."</string>
    <string name="support_summary" msgid="2705726826263742491">"Članci za pomoć, telefon i chat, početak"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Račun za sadržaj"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID fotografije"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Ekstremne prijetnje"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Primite upozorenja o ekstremnim prijetnjama po život i imovinu"</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Ozbiljne prijetnje"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Primi upozorenja o ozbiljnim prijetnjama po život i imovinu"</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"AMBER upozorenja"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Prijem objava o otmicama djece"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Ponovi"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Omogući Upravitelj pozivima"</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Dozvoli ovoj usluzi da upravlja upućivanjem poziva."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Upravitelj za pozive"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="4124461751977706019">"Poruke upozorenja"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Mrežni operateri"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Nazivi pristupnih tačaka"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="2544026384901010606">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="480304128966864221">"Napredno pozivanje"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="6839553611093179243">"Pozivanje putem 4G mreže"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="4156658595226379286">"Koristi LTE usluge za poboljšanje glasovne i drugih komunikacija (preporučeno)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="6145184730437907078">"Koristi usluge 4G mreže za poboljšanje glasovne i drugih komunikacija (preporučeno)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Tip preferirane mreže"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (preporučeno)"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"SIM za Work"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Aplikacija i pristup sadržaju"</string>
    <string name="user_rename" msgid="8523499513614655279">"PROMIJENI NAZIV"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Postavi ograničenja za aplikacije"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Kontroliše <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Ova aplikacija može pristupiti vašim računima"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="6968697624437267294">"Ova aplikacija može pristupati vašim računima. Kontrolu vrši <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"WiFi i mobilne mreže"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Dozvoli izmjenu postavki za WiFi i mobilne mreže"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Dozvoli izmjenu Bluetooth uparivanja i postavki"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Dozvoli razmjenu podataka kada <xliff:g id="DEVICE_NAME">%1$s</xliff:g> dodiruje drugi NFC uređaj"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Dopušta razmjenu podataka kada tablet dodirne drugi uređaj"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Omogućavanje razmjene podataka kada telefon dodirne drugi uređaj"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Lokacija"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Omogućava da aplikacije koriste informacije o lokaciji"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Nazad"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Naprijed"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Kraj"</string>
    <string name="user_image_take_photo" msgid="4038201220173969126">"Snimite fotografiju"</string>
    <string name="user_image_choose_photo" msgid="7643300431215339631">"Odaberite sliku"</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Odaberite fotografiju"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"SIM kartice"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"SIM kartice"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<xliff:g id="SIM_NAME">%1$s</xliff:g> – <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7900721153345139783">"SIM kartice su promijenjene"</string>
    <string name="sim_cards_changed_message_summary" msgid="8258058274989383204">"Dodirnite za podešavanje aktivnosti"</string>
    <string name="sim_cellular_data_unavailable" msgid="9109302537004566098">"Prijenos podataka na mobilnoj mreži je nedostupan"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="5416535001368135327">"Dodirnite za odabir SIM kartice za prijenos podataka"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Uvijek koristi ovo za pozive"</string>
    <string name="select_sim_for_data" msgid="2366081042162853044">"Odaberite SIM za podatke"</string>
    <string name="select_sim_for_sms" msgid="6232060107120265044">"Odaberite SIM za SMS"</string>
    <string name="data_switch_started" msgid="2040761479817166311">"Prebacuje se SIM kartica za prijenos podataka. Ovo može potrajati najviše jednu minutu..."</string>
    <string name="select_sim_for_calls" msgid="3503094771801109334">"Poziv putem"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Odaberite SIM karticu"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"SIM kartica je prazna"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Ime SIM-a"</string>
    <string name="sim_name_hint" msgid="7038643345238968930">"Unesite ime SIM-a"</string>
    <string name="sim_editor_title" msgid="4034301817366627870">"SIM slot %1$d"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Operater"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Broj"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"Boja SIM-a"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"Odaberite SIM karticu"</string>
    <string name="color_orange" msgid="4417567658855022517">"Narandžasta"</string>
    <string name="color_purple" msgid="3888532466427762504">"Ljubičasta"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"SIM kartica nije umetnuta"</string>
    <string name="sim_status_title" msgid="6744870675182447160">"Status SIM-a"</string>
    <string name="sim_status_title_sim_slot" msgid="5725659316463979194">"Status SIM-a (utor za sim %1$d)"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Uzvrati poziv putem zadanog SIM-a"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"SIM za odlazne pozive"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Ostale postavke poziva"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"Pron. preferiranih mreža"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Onem. emit. imena mreže"</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"Funkcija Onemogući emitiranje imena mreže sprečava da treće strane dobiju informacije o vašoj mreži."</string>
    <string name="preferred_network_offload_popup" msgid="2252915199889604600">"Onemogućavanje emitiranja imena mreže će spriječiti automatsko povezivanje na skrivene mreže."</string>
    <string name="sim_signal_strength" msgid="9144010043784767984">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="6272913297433198340">"SIM kartice promijenjene."</string>
    <string name="sim_notification_summary" msgid="8858043655706669772">"Dodirnite za postavke"</string>
    <string name="sim_pref_divider" msgid="6778907671867621874">"Željeni SIM za"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="7941299533514115976">"Pitaj svaki put"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Potreban odabir"</string>
    <string name="sim_selection_channel_title" msgid="2760909074892782589">"Odabir SIM-a"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Postavke"</string>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="5597356221942118048">
      <item quantity="one">Prikaži %d skrivenu stavku</item>
      <item quantity="few">Prikaži %d skrivene stavke</item>
      <item quantity="other">Prikaži %d skrivenih stavki</item>
    </plurals>
    <string name="network_dashboard_title" msgid="3135144174846753758">"Mreža i internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="3851083934739500429">"mobilna mreža"</string>
    <string name="network_dashboard_summary_data_usage" msgid="3843261364705042212">"prijenos podataka"</string>
    <string name="network_dashboard_summary_hotspot" msgid="8494210248613254574">"pristupna tačka"</string>
    <string name="connected_devices_dashboard_title" msgid="2355264951438890709">"Povezani uređaji"</string>
    <string name="connected_devices_dashboard_summary" msgid="2665221896894251402">"Bluetooth, način rada za vožnju, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="3840842725283655533">"Bluetooth, način rada za vožnju"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="5018708106066758867">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="5250078362483148199">"Bluetooth"</string>
    <string name="app_and_notification_dashboard_title" msgid="7838365599185397539">"Aplikacije i obavještenja"</string>
    <string name="app_and_notification_dashboard_summary" msgid="6513508041918469381">"Asistent, nedavne aplikacije, zadane aplikacije"</string>
    <string name="notification_settings_work_profile" msgid="3186757479243373003">"Pristup obavještenjima nije dostupan za aplikacije u novom radnom profilu."</string>
    <string name="account_dashboard_title" msgid="5895948991491438911">"Računi"</string>
    <string name="account_dashboard_default_summary" msgid="3998347400161811075">"Nije dodan nijedan račun"</string>
    <string name="app_default_dashboard_title" msgid="7342549305933047317">"Zadane aplikacije"</string>
    <string name="system_dashboard_summary" msgid="6839969589170062254">"Jezici, pokreti, vrijeme, sigurnosna kopija"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Postavke"</string>
    <string name="keywords_wifi" msgid="3646884600964177062">"wifi, wi-fi, veza s mrežom, internet, bežično, podaci, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="8745178424405564885">"WiFi obavještenje, wifi obavještenje"</string>
    <string name="keywords_auto_brightness" msgid="2109098908025156362">"Automatska osvijetljenost"</string>
    <string name="keywords_vibrate_on_touch" msgid="1494239633254176598">"Zaustavi vibriranje, dodir, tastaturu"</string>
    <string name="keywords_time_format" msgid="5581515674151927461">"Koristi 24-satni format"</string>
    <string name="keywords_storage_files" msgid="7075933058850826819">"Preuzmi"</string>
    <string name="keywords_app_default" msgid="5822717006354487071">"Otvori koristeći"</string>
    <string name="keywords_applications_settings" msgid="1268353611121497450">"Aplikacije"</string>
    <string name="keywords_time_zone" msgid="998254736898753085">"vremenska zona"</string>
    <string name="keywords_draw_overlay" msgid="4130899177619041842">"Skočni prozor za chat"</string>
    <string name="keywords_flashlight" msgid="6161632177705233710">"Svjetiljka, svjetlo, lampa"</string>
    <string name="keywords_change_wifi_state" msgid="627068244033681010">"wifi, wi-fi, aktivacija/deaktivacija, kontrola"</string>
    <string name="keywords_more_mobile_networks" msgid="8995946622054642367">"mobilni, mobilni operater, bežični, podaci, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="1784064367330122679">"wifi, wi-fi, pozovi, pozivanje"</string>
    <string name="keywords_display" msgid="8910345814565493016">"ekran, osjetljiv na dodir"</string>
    <string name="keywords_display_brightness_level" msgid="3138350812626210404">"zatamnjeni ekran, osjetljiv na dodir, baterija, svijetlo"</string>
    <string name="keywords_display_night_display" msgid="2534032823231355074">"zatamnjeni ekran, noć, boja, noćna smjena, osvjetljenje, boja ekrana, boja"</string>
    <string name="keywords_display_wallpaper" msgid="7362076351860131776">"pozadina, personalizirati, prilagoditi ekran"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"veličina teksta"</string>
    <string name="keywords_display_cast_screen" msgid="1209288893924324904">"projiciranje, emitiranje, preslikavanje ekrana, dijeljenje ekrana, preslikavanje, dijeli ekran, emitiranje ekrana"</string>
    <string name="keywords_storage" msgid="3299217909546089225">"prostor, disk, čvrsti disk, upotreba uređaja"</string>
    <string name="keywords_battery" msgid="1173830745699768388">"potrošnja energije, punjenje"</string>
    <string name="keywords_spell_checker" msgid="1399641226370605729">"pravopis, rječnik, provjera pravopisa, automatsko ispravljanje"</string>
    <string name="keywords_voice_input" msgid="769778245192531102">"prepoznavač, ulaz, govor, govoriti, jezik, rad bez dodira, prepoznavanje, uvredljivo, riječ, zvuk, istorija, bluetooth slušalice"</string>
    <string name="keywords_text_to_speech_output" msgid="5150660047085754699">"stopa, jezik, zadano, govori, govoriti, tts, pristupačnost, čitač ekrana, slijepi"</string>
    <string name="keywords_date_and_time" msgid="758325881602648204">"sat, vojni"</string>
    <string name="keywords_network_reset" msgid="6024276007080940820">"resetirati, vratiti, fabričke postavke"</string>
    <string name="keywords_factory_data_reset" msgid="2261491208836438871">"uništiti, izbrisati, vratiti, obrisati, ukloniti, vratiti na fabričke postavke"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"štampač"</string>
    <string name="keywords_sounds" msgid="5633386070971736608">"zvuk sa zvučnika, zvučnik, jačina zvuka, isključenje zvuka, tišina, zvučni zapis, muzika"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="5426093074031208917">"ne ne uznemiravaj, prekinuti, prekidanje, pauza"</string>
    <string name="keywords_app" msgid="6334757056536837791">"RAM"</string>
    <string name="keywords_location" msgid="4132655528196729043">"u blizini, lokacija, historija, izvještavanje, GPS"</string>
    <string name="keywords_accounts" msgid="1957925565953357627">"račun"</string>
    <string name="keywords_users" msgid="3434190133131387942">"ograničenje, ograničavanje, ograničen"</string>
    <string name="keywords_keyboard_and_ime" msgid="9143339015329957107">"korekcija teksta, ispravan, zvuk, vibrirati, auto, jezik, gest, predložiti, prijedlog, tema, uvredljivo, riječ, vrsta, emoji, međunarodna"</string>
    <string name="keywords_reset_apps" msgid="5293291209613191845">"ponovo podesi, željene postavke, zadano"</string>
    <string name="keywords_all_apps" msgid="7814015440655563156">"aplikacije, preuzimanje, aplikacije, sistem"</string>
    <string name="keywords_app_permissions" msgid="4229936435938011023">"aplikacije, odobrenja, sigurnost"</string>
    <string name="keywords_default_apps" msgid="223872637509160136">"aplikacije, zadane"</string>
    <string name="keywords_ignore_optimizations" msgid="6102579291119055029">"ignorirati optimizacije, doziranje, stanje mirovanja aplikacije"</string>
    <string name="keywords_color_mode" msgid="6362744316886077510">"jarke, RGB, sRGB, boja, prirodno, standardo"</string>
    <string name="keywords_color_temperature" msgid="6239410718075715449">"boja, temperatura, D65, D73, bijela, žuta, plava, topla, hladna"</string>
    <string name="keywords_lockscreen" msgid="5746561909668570047">"prevuci za otključavanje, lozinka, uzorak, PIN"</string>
    <string name="keywords_profile_challenge" msgid="789611397846512845">"poslovni izazov, rad, profil"</string>
    <string name="keywords_unification" msgid="1922900767659821025">"radni profil, upravljani profil, ujediniti, ujedinjenje, rad, profil"</string>
    <string name="keywords_gesture" msgid="3526905012224714078">"pokreti"</string>
    <string name="keywords_payment_settings" msgid="5220104934130446416">"plati, dodir, plaćanja"</string>
    <string name="keywords_backup" msgid="470070289135403022">"sigurnosna kopija"</string>
    <string name="keywords_assist_gesture_launch" msgid="813968759791342591">"pokret"</string>
    <string name="keywords_face_unlock" msgid="254144854349092754">"lice, otključaj, autentifikacija, prijava"</string>
    <string name="keywords_imei_info" msgid="7230982940217544527">"imei, meid, min, prl verzija, imei sv"</string>
    <string name="keywords_sim_status" msgid="1474422416860990564">"mreža, stanje mobilne mreže, stanje usluge, jačina signala, vrsta mobilne mreže, roming, iccid"</string>
    <string name="keywords_model_and_hardware" msgid="1459248377212829642">"serijski broj, verzija hardvera"</string>
    <string name="keywords_android_version" msgid="9069747153590902819">"nivo sigurnosne zakrpe za android, verzija nemoduliranog signala, osnovna verzija"</string>
    <string name="keywords_dark_ui_mode" msgid="8999745898782012625">"tema, svijetlo, tamno, način"</string>
    <string name="keywords_financial_apps_sms_access" msgid="391349097813320537">"finansijska aplikacija, sms, odobrenje"</string>
    <string name="keywords_systemui_theme" msgid="9112852512550404882">"tema po mraku"</string>
    <string name="keywords_device_feedback" msgid="564493721125966719">"greška"</string>
    <string name="keywords_ambient_display_screen" msgid="5874969496073249362">"Ambijentalni prikaz, Prikaz zaključavanja ekrana"</string>
    <string name="keywords_lock_screen_notif" msgid="6716392855813576197">"obavještenja na zaključanom ekranu, obavještenja"</string>
    <string name="keywords_face_settings" msgid="7505388678116799329">"lice"</string>
    <string name="keywords_fingerprint_settings" msgid="4425098764810291897">"otisak prsta, dodati otisak prsta"</string>
    <string name="keywords_display_auto_brightness" msgid="4130320471533951796">"zatamnjenje ekrana, ekran osjetljiv na dodir, baterija, pametna osvijetljenost, dinamička osvijetljenost"</string>
    <string name="keywords_display_adaptive_sleep" msgid="6865504720946121402">"zatamni ekran, stanje mirovanja, baterija, istek vremena, pažnja, prikaz, ekran, neaktivnost"</string>
    <string name="keywords_auto_rotate" msgid="5620879898668211494">"rotirati, obrnuti, rotacija, uspravno, vodoravno, orijentacija, vertikalno, horizontalno"</string>
    <string name="keywords_system_update_settings" msgid="7752189778843741773">"nadograditi, android"</string>
    <string name="keywords_zen_mode_settings" msgid="6526742836231604995">"dnd, raspored, obavještenja, blokirati, tišina, vibriranje, stanje mirovanja, rad, fokusiranje, zvuk, isključenje zvuka, dan, radni dan, vikend, radni dan uvečer, događaj"</string>
    <string name="keywords_screen_timeout" msgid="8161370660970309476">"ekran, vrijeme zaključavanja, istek vremena, zaključani ekran"</string>
    <string name="keywords_storage_settings" msgid="297283751968446577">"memorija, keš memorija, podaci, izbrisati, obrisati, osloboditi, prostor"</string>
    <string name="keywords_bluetooth_settings" msgid="6804844062789439858">"povezan, uređaj, slušalice, slušalice s mikrofonom, zvučnik, bežično, uparivanje, slušalice za umetanje u uho, muzika, medij"</string>
    <string name="keywords_wallpaper" msgid="5058364390917429896">"pozadina, ekran, zaključani ekran, tema"</string>
    <string name="keywords_assist_input" msgid="5017533309492679287">"zadani, asistent"</string>
    <string name="keywords_default_payment_app" msgid="3838565809518896799">"plaćanje, zadano"</string>
    <string name="keywords_ambient_display" msgid="3103487805748659132">"dolazno obavještenje"</string>
    <string name="keywords_hotspot_tethering" msgid="1137511742967410918">"povezivanje putem usb uređaja, povezivanje putem bluetooth uređaja, wifi pristupna tačka"</string>
    <string name="keywords_touch_vibration" msgid="5983211715076385822">"haptika, vibriranje, ekran, osjetljivost"</string>
    <string name="keywords_ring_vibration" msgid="4652101158979064884">"haptika, vibriranje, telefon, poziv, osjetljivost, zvono"</string>
    <string name="keywords_notification_vibration" msgid="31924624421190547">"haptika, vibriranje, osjetljivost"</string>
    <string name="keywords_battery_saver_sticky" msgid="5586215686021650278">"ušteda baterije, ljepljivo, istrajnost, ušteda energije, baterija"</string>
    <string name="default_sound" msgid="8821684447333687810">"Podrazumijevani zvuk"</string>
    <string name="sound_settings_summary" msgid="4100853606668287965">"Jačina zvuka zvona je na <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="3402435125958012986">"Jačina zvuka, vibracija, Ne ometaj"</string>
    <string name="sound_settings_summary_vibrate" msgid="1869282574422220096">"Zvono je postavljeno da vibrira"</string>
    <string name="sound_settings_summary_silent" msgid="5074529767435584948">"Zvono je utišano"</string>
    <string name="sound_settings_example_summary" msgid="2404914514266523165">"Jačina zvuka zvona je na 80%"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Jačina zvuka medija"</string>
    <string name="remote_media_volume_option_title" msgid="7602586327091007461">"Jačina zvuka emitiranja"</string>
    <string name="call_volume_option_title" msgid="1265865226974255384">"Jačina zvuka tokom poziva"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Jačina zvuka alarma"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Jačina zvuka zvona"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Jačina zvuka za obavještenja"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Melodija zvona telefona"</string>
    <string name="notification_ringtone_title" msgid="4468722874617061231">"Zadani zvuk obavještenja"</string>
    <string name="notification_unknown_sound_title" msgid="2535027767851838335">"Zvuk iz aplikacije"</string>
    <string name="notification_sound_default" msgid="565135733949733766">"Zadani zvuk obavještenja"</string>
    <string name="alarm_ringtone_title" msgid="6344025478514311386">"Zadani zvuk alarma"</string>
    <string name="vibrate_when_ringing_title" msgid="8658910997501323472">"Vibriranje za pozive"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Drugi zvukovi"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Tonovi tastature telefona"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Zvukovi zaključavanja ekrana"</string>
    <string name="charging_sounds_title" msgid="3379885700913955599">"Zvukovi/vibracija pri punjenju"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Zvukovi priključne stanice"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Zvukovi pri dodiru"</string>
    <string name="vibrate_on_touch_title" msgid="1510405818894719079">"Vibracija pri dodiru"</string>
    <string name="vibrate_on_touch_summary" msgid="8015901758501868229">"Haptičke povratne informacije za dodir, tastaturu i drugo"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Zvučnik priključne stanice reprodukuje zvuk"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Svi zvukovi"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Samo zvukovi medijskih sadržaja"</string>
    <string name="emergency_tone_silent" msgid="3750231842974733677">"Tišina"</string>
    <string name="emergency_tone_alert" msgid="8523447641290736852">"Tonovi"</string>
    <string name="emergency_tone_vibrate" msgid="2278872257053690683">"Vibracije"</string>
    <string name="boot_sounds_title" msgid="567029107382343709">"Uključivanje zvukova"</string>
    <string name="live_caption_title" msgid="2241633148129286971">"Titlovanje uživo"</string>
    <string name="live_caption_summary" msgid="3365960379606535783">"Automatski titluj medije"</string>
    <string name="zen_mode_settings_summary_off" msgid="6119891445378113334">"Nikada"</string>
    <plurals name="zen_mode_settings_summary_on" formatted="false" msgid="2249085722517252521">
      <item quantity="one"><xliff:g id="ON_COUNT">%d</xliff:g> pravilo je omogućeno</item>
      <item quantity="few"><xliff:g id="ON_COUNT">%d</xliff:g> pravila su omogućena</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> pravila je omogućeno</item>
    </plurals>
    <string name="zen_mode_settings_title" msgid="1066226840983908121">"Ne ometaj"</string>
    <!-- no translation found for zen_mode_slice_subtitle (1495506059205752083) -->
    <skip />
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="2297134204747331078">"Uključi način rada Ne ometaj"</string>
    <string name="zen_mode_behavior_settings_title" msgid="5453115212674008032">"Izuzeci"</string>
    <string name="zen_mode_duration_settings_title" msgid="8471983919324532829">"Zadano trajanje"</string>
    <string name="zen_mode_behavior_allow_title" msgid="3845615648136218141">"Omogući zvuke i vibracije od"</string>
    <string name="zen_mode_behavior_no_sound" msgid="1219626004723208056">"Bez zvuka"</string>
    <string name="zen_mode_behavior_total_silence" msgid="2229976744274214528">"Potpuna tišina"</string>
    <string name="zen_mode_behavior_no_sound_except" msgid="4968477585788243114">"Bez zvuka osim <xliff:g id="CATEGORIES">%1$s</xliff:g>"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="6455884547877702466">"Bez zvuka, osim upozorenja i medija"</string>
    <string name="zen_mode_automation_settings_title" msgid="6155298704165984370">"Rasporedi"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5975522152123354381">"Izbrišite rasporede"</string>
    <string name="zen_mode_schedule_delete" msgid="5717258786128155695">"Izbriši"</string>
    <string name="zen_mode_rule_name_edit" msgid="812185626159430507">"Uredi"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="8995524726286378583">"Rasporedi"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="4773111805919088437">"Raspored"</string>
    <string name="zen_mode_schedule_category_title" msgid="5482757877262584975">"Raspored"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="4321254843908888574">"Utišaj telefon u određeno vrijeme"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="6223252025075862701">"Postavite pravila za način rada Ne ometaj"</string>
    <string name="zen_mode_schedule_title" msgid="8616187805239590649">"Raspored"</string>
    <string name="zen_mode_use_automatic_rule" msgid="489102635414919052">"Koristi raspored"</string>
    <string name="zen_mode_option_important_interruptions" msgid="3903928008177972500">"Samo prioritetno"</string>
    <string name="zen_mode_option_alarms" msgid="5785372117288803600">"Samo alarmi"</string>
    <string name="zen_mode_option_no_interruptions" msgid="8107126344850276878">"Potpuna tišina"</string>
    <string name="zen_mode_summary_combination" msgid="8715563402849273459">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="6751708745442997940">"Blokiranje vizuelnih ometanja"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="6308824824208120508">"Dozvolite vizualnu signalizaciju"</string>
    <string name="zen_mode_settings_category" msgid="8404473163624911791">"Kada je uključen način rada Ne ometaj"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="8138441771855063771">"Ograniči obavještenja"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="3690261619682396872">"Obavještenja bez zvuka"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="5810076116489877312">"Obavještenja ćete vidjeti na ekranu"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="3465600930732602159">"Telefon neće zvoniti ili vibrirati kada stignu nova obavještenja."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5305121630186687339">"Obavještenja bez vizuelnih elemenata ili zvuka"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="7555448406901864904">"Obavještenja nećete vidjeti niti čuti"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="1069960859746788356">"U slučaju novih ili postojećih obavještenja, vaš telefon ih neće prikazivati, neće vibrirati niti zvoniti. Imajte na umu da će se kritična obavještenja o aktivnosti i statusu telefona i dalje pojavljivati.\n\nKada isključite funkciju Ne ometaj, propuštena obavještenja ćete pronaći prevlačenjem s vrha ekrana prema dolje."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="7498689167767941034">"Prilagođeno"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4250962169561739747">"Omogući prilagođenu postavku"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="6676997522330453597">"Ukloni prilagođenu postavku"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="5450158135853888485">"Obavještenja bez zvuka"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="7416121534987213074">"Djelimično skriveno"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="3618285192806732504">"Obavještenja bez vizuelnih elemenata ili zvuka"</string>
    <string name="zen_mode_what_to_block_title" msgid="5480903548365697159">"Prilagođena ograničenja"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="4659484530849212827">"Kada je ekran uključen"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="4276414460889400625">"Kada je ekran isključen"</string>
    <string name="zen_mode_block_effect_sound" msgid="7383953383758025895">"Isključi zvuk i vibraciju"</string>
    <string name="zen_mode_block_effect_intent" msgid="350764335391428447">"Nemoj uključivati ekran"</string>
    <string name="zen_mode_block_effect_light" msgid="8106976110224107316">"Nemoj bljeskati"</string>
    <string name="zen_mode_block_effect_peek" msgid="6836997464098657115">"Nemoj isticati obavještenja na ekranu"</string>
    <string name="zen_mode_block_effect_status" msgid="1651527249762752921">"Sakrij ikone stat. trake u vrhu ekrana"</string>
    <string name="zen_mode_block_effect_badge" msgid="214553506070597320">"Sakrij tačke za obavj. na ikonama apl."</string>
    <string name="zen_mode_block_effect_ambient" msgid="4704755879961212658">"Nemoj buditi zbog obavještenja"</string>
    <string name="zen_mode_block_effect_list" msgid="3882541635576592530">"Sakrij s liste obavještenja"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="2617875282623486256">"Nikada"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="1230265589026355094">"Kada je ekran isključen"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="6017536991063513394">"Kada je ekran uključen"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1065107568053759972">"Zvuk i vibracija"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="3635646031575107456">"Zvuk, vibracija i neki vizuelni znakovi obavještenja"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="1213328945418248026">"Zvuk, vibracija i vizuelni znakovi obavještenja"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="5710896246703497760">"Obavještenja koja su potrebna za osnovne radnje i status telefona nikada se neće sakriti"</string>
    <string name="zen_mode_no_exceptions" msgid="7653433997399582247">"Ništa"</string>
    <string name="zen_mode_other_options" msgid="520015080445012355">"druge opcije"</string>
    <string name="zen_mode_add" msgid="90014394953272517">"Dodaj"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="8287824809739581837">"Uključi"</string>
    <string name="zen_mode_button_turn_on" msgid="2824380626482175552">"Uključi sada"</string>
    <string name="zen_mode_button_turn_off" msgid="6181953727880503094">"Isključi sada"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8860646554263965569">"Način rada Ne ometaj će biti uključen do <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="7186615007561990908">"Način rada Ne ometaj će biti uključen dok ga ne isključite"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="6195725842906270996">"Način rada Ne ometaj je automatski uključen na osnovu rasporeda (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="1721179577382915270">"Način rada Ne ometaj je automatski uključila aplikacija (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="1965922539531521052">"Način rada Ne ometaj je uključen za <xliff:g id="RULE_NAMES">%s</xliff:g> zajedno sa zadanim postavkama."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="7555742240858292255"><annotation id="link">" Vidi prilagođene postavke"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="2078370238113347720">"Samo prioriteti"</string>
    <string name="zen_mode_and_condition" msgid="4927230238450354412">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="1202632669798211342">"Uključeno / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off_with_info" msgid="2348629457144123849">"Isključeno / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off" msgid="4375814717589425561">"Isključeno"</string>
    <string name="zen_mode_sound_summary_on" msgid="7718273231309882914">"Uključeno"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="5976427426278136178">"Pitaj svaki put (osim ako se automatski uključi)"</string>
    <string name="zen_mode_duration_summary_forever" msgid="3144786357459137066">"Dok ne isključite (osim ako se automatski uključi)"</string>
    <plurals name="zen_mode_duration_summary_time_hours" formatted="false" msgid="1060823390336822337">
      <item quantity="one"><xliff:g id="NUM_HOURS">%d</xliff:g> sat (osim ako se automatski uključi)</item>
      <item quantity="few"><xliff:g id="NUM_HOURS">%d</xliff:g> sata (osim ako se automatski uključi)</item>
      <item quantity="other"><xliff:g id="NUM_HOURS">%d</xliff:g> sati (osim ako se automatski uključi)</item>
    </plurals>
    <string name="zen_mode_duration_summary_time_minutes" msgid="3959860288930526323">"<xliff:g id="NUM_MINUTES">%d</xliff:g> min (osim ako se automatski uključi)"</string>
    <plurals name="zen_mode_sound_summary_summary_off_info" formatted="false" msgid="6751226506661227581">
      <item quantity="one"><xliff:g id="ON_COUNT">%d</xliff:g> raspored se može automatski uključiti</item>
      <item quantity="few"><xliff:g id="ON_COUNT">%d</xliff:g> rasporeda se mogu automatski uključiti</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> rasporeda se može automatski uključiti</item>
    </plurals>
    <string name="zen_category_behavior" msgid="554277240833452070">"Isključi zvuk uređaja ali dozvoli izuzetke"</string>
    <string name="zen_category_exceptions" msgid="7601136604273265629">"Izuzeci"</string>
    <string name="zen_category_schedule" msgid="9000447592251450453">"Raspored"</string>
    <string name="zen_sound_title" msgid="4461494611692749446">"Prikaži sve izuzetke"</string>
    <string name="zen_sound_footer" msgid="7621745273287208979">"Kada je uključen način rada Ne ometaj, zvuk i vibracija će biti isključeni, osim za stavke koje omogućite iznad."</string>
    <string name="zen_sound_category_title" msgid="4336596939661729188">"Isključi zvuk za sve osim"</string>
    <string name="zen_sound_all_muted" msgid="4850363350480968114">"Isključen zvuk"</string>
    <string name="zen_sound_none_muted" msgid="3938508512103612527">"Zvuk nije isključen"</string>
    <string name="zen_sound_one_allowed" msgid="8447313454438932276">"Zvuk je isključen, ali omogući <xliff:g id="SOUND_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_sound_two_allowed" msgid="980491120444358550">"Zvuk je isključen, ali omogući <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g> i <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_sound_three_allowed" msgid="3455767205934547985">"Zvuk je isključen, ali omogući <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g>, <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g> i <xliff:g id="SOUND_TYPE_2">%3$s</xliff:g>"</string>
    <string name="zen_custom_settings_dialog_title" msgid="3999383687283620283">"Prilagođene postavke"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="7056997717364939238">"Pregledajte raspored"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="5302885851078421866">"Razumijem"</string>
    <string name="zen_custom_settings_notifications_header" msgid="6931035609369698584">"Obavještenja"</string>
    <string name="zen_custom_settings_duration_header" msgid="1190989278065507035">"Trajanje"</string>
    <string name="zen_msg_event_reminder_title" msgid="5137894077488924820">"Poruke, događaji i podsjetnici"</string>
    <string name="zen_msg_event_reminder_footer" msgid="4376930591019535192">"Kada je uključen način rada Ne ometaj, zvuk poruka, podsjetnika i događaja će se isključiti, osim za stavke kojim dozvolite iznad. Postavke poruka možete podesiti da omogućite prijateljima, porodici ili drugim kontaktima da vas kontaktiraju."</string>
    <string name="zen_onboarding_ok" msgid="6131211000824433013">"Gotovo"</string>
    <string name="zen_onboarding_settings" msgid="9046451821239946868">"Postavke"</string>
    <string name="zen_onboarding_new_setting_title" msgid="1893095176110470711">"Obavještenja bez vizuelnih elemenata ili zvuka"</string>
    <string name="zen_onboarding_current_setting_title" msgid="776426065129609376">"Obavještenja bez zvuka"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="6293026064871880706">"Obavještenja nećete vidjeti ili čuti. Dozvoljeni su pozivi od kontakata označenih zvjezdicom i ponovljenih pozivalaca."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="1280614488924843713">"(Trenutna postavka)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="1352808651270918932">"Promijeniti postavke obavještenja načina rada Ne ometaj?"</string>
    <string name="sound_work_settings" msgid="6774324553228566442">"Zvukovi radnog profila"</string>
    <string name="work_use_personal_sounds_title" msgid="1148331221338458874">"Koristite zvukove ličnog profila"</string>
    <string name="work_use_personal_sounds_summary" msgid="6207040454949823153">"Zvukovi su isti za radni i lični profil"</string>
    <string name="work_ringtone_title" msgid="5806657896300235315">"Melodija zvona radnog telefona"</string>
    <string name="work_notification_ringtone_title" msgid="6081247402404510004">"Zadani zvuk radnih obavještenja"</string>
    <string name="work_alarm_ringtone_title" msgid="1441926676833738891">"Zadani zvuk radnog alarma"</string>
    <string name="work_sound_same_as_personal" msgid="3123383644475266478">"Isto kao kod ličnog profila"</string>
    <string name="work_sync_dialog_title" msgid="7123973297187354813">"Zamijeniti zvukove?"</string>
    <string name="work_sync_dialog_yes" msgid="7243884940551635717">"Zamijeni"</string>
    <string name="work_sync_dialog_message" msgid="7841728953710863208">"Zvukovi vašeg ličnog profila će se koristi za vaš radni profil"</string>
    <string name="ringtones_install_custom_sound_title" msgid="5948792721161302255">"Želite li dodati prilagođeni zvuk?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="2195581481608512786">"Ovaj fajl će se kopirati u folder <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="5675912303120102366">"Melodije zvona"</string>
    <string name="other_sound_category_preference_title" msgid="2521096636124314015">"Ostali zvukovi i vibracije"</string>
    <string name="configure_notification_settings" msgid="7616737397127242615">"Obavještenja"</string>
    <string name="recent_notifications" msgid="5660639387705060156">"Nedavno poslano"</string>
    <string name="recent_notifications_see_all_title" msgid="8572160812124540326">"Pogledajte sve tokom posljednjih 7 dana"</string>
    <string name="advanced_section_header" msgid="8833934850242546903">"Napredno"</string>
    <string name="profile_section_header" msgid="2320848161066912001">"Obavještenja za posao"</string>
    <!-- no translation found for smart_notifications_title (475969117151722852) -->
    <skip />
    <!-- no translation found for asst_capability_prioritizer_title (6691908606916292167) -->
    <skip />
    <!-- no translation found for asst_capability_prioritizer_summary (3532556835426559362) -->
    <skip />
    <string name="asst_capabilities_actions_replies_title" msgid="2482989905050401969">"Pametne radnje i odgovori"</string>
    <!-- no translation found for asst_capabilities_actions_replies_summary (5358499322896238048) -->
    <skip />
    <string name="hide_silent_icons_title" msgid="2378514357635207742">"Sakrij ikone statusa tihih obavještenja"</string>
    <string name="hide_silent_icons_summary" msgid="7479863645940885952">"Sakrijte ikone za tiha obavještenja na statusnoj traci"</string>
    <string name="notification_badging_title" msgid="5938709971403474078">"Dozvoli tačke za obavještenja"</string>
    <string name="notification_bubbles_title" msgid="526545466417027926">"Mjehurići"</string>
    <string name="notification_bubbles_summary" msgid="5269674863510678257">"Pomoću plutajućih prečica od svuda možete brzo pristupiti sadržaju aplikacije."</string>
    <string name="bubbles_feature_education" msgid="69923617148394578">"Neka obavještenja i drugi sadržaj se mogu prikazati kao mjehurići na ekranu. Dodirnite mjehurić da ga otvorite. Da ga odbacite, povucite ga prema dolje na ekranu."</string>
    <string name="bubbles_app_toggle_title" msgid="9143702245165359360">"Mjehurići"</string>
    <string name="bubbles_app_toggle_summary" msgid="7714358008428342285">"Dozvoli da aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> prikazuje neka obavještenja kao mjehuriće"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="8013961655723563787">"Uključite mjehuriće"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="3616822820657195387">"Da uključite mjehuriće za ovu aplikaciju, prvo ih morate uključiti na uređaju. To će uticati na druge aplikacije u kojima ste prethodno uključili mjehuriće."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="5317196831268846883">"Uključi za uređaj"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8176870537170586852">"Otkaži"</string>
    <string name="swipe_direction_title" msgid="6877543492435053137">"Radnje prevlačenja"</string>
    <string name="swipe_direction_ltr" msgid="3623394320915041215">"Prevucite desno za odbacivanje, a lijevo za prikaz menija"</string>
    <string name="swipe_direction_rtl" msgid="4972099509548044938">"Prevucite lijevo za odbacivanje, a desno za prikaz menija"</string>
    <string name="notification_pulse_title" msgid="1905382958860387030">"Trepćuće svjetlo"</string>
    <!-- no translation found for lock_screen_notifications_title (7604704224172951090) -->
    <skip />
    <string name="locked_work_profile_notification_title" msgid="8327882003361551992">"Kada je radni profil zaključan"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Prikaži sav sadržaj obavještenja"</string>
    <!-- no translation found for lock_screen_notifications_summary_hide (1133085507139112569) -->
    <skip />
    <string name="lock_screen_notifications_summary_disable" msgid="859628910427886715">"Uopće ne prikazuj obavještenja"</string>
    <!-- no translation found for lock_screen_notifications_interstitial_message (3143593517597479937) -->
    <skip />
    <!-- no translation found for lock_screen_notifications_interstitial_title (709573564312902481) -->
    <skip />
    <string name="lock_screen_notifications_summary_show_profile" msgid="835870815661120772">"Prikaži sav sadržaj obavještenja radnog profila"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2005907007779384635">"Sakrij osjetljivi poslovni sadržaj"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="8307705621027472346">"Kada je uređaj zaključan, na koji način želite da se prikazuju obavještenja profila?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="3169806586032521333">"Obavještenja profila"</string>
    <string name="notifications_title" msgid="8086372779371204971">"Obavještenja"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Obavještenja o aplikaciji"</string>
    <string name="notification_channel_title" msgid="2260666541030178452">"Kategorija obavještenja"</string>
    <string name="notification_group_title" msgid="7180506440133859601">"Grupa kategorija obavještenja"</string>
    <string name="notification_importance_title" msgid="4368578960344731828">"Ponašanje"</string>
    <string name="notification_importance_unspecified" msgid="6622173510486113958">"Dozvoli zvuk"</string>
    <string name="notification_importance_blocked" msgid="7938180808339386300">"Nikad ne prikazuj obavještenja"</string>
    <string name="notification_importance_min" msgid="9054819132085066824">"Prikaži bez zvuka i minimiziraj"</string>
    <string name="notification_importance_low" msgid="2445139943005315690">"Prikaži bez zvuka"</string>
    <string name="notification_importance_default" msgid="5958338024601957516">"Reproduciraj zvuk"</string>
    <string name="notification_importance_high" msgid="2082429479238228527">"Pusti zvuk i prikaži na ekranu"</string>
    <string name="notification_importance_high_silent" msgid="2667033773703765252">"Prikaži na ekranu"</string>
    <string name="notification_importance_min_title" msgid="5024538864029341539">"Minimiziraj"</string>
    <string name="notification_importance_low_title" msgid="8131254047772814309">"Srednja"</string>
    <string name="notification_importance_default_title" msgid="9120383978536089489">"Visoka"</string>
    <string name="notification_importance_high_title" msgid="8792310396497954857">"Prikaži na ekranu"</string>
    <string name="notification_block_title" msgid="1366361048463539674">"Blokiraj"</string>
    <!-- no translation found for notification_silence_title (8575600650015431622) -->
    <skip />
    <!-- no translation found for notification_alert_title (7426286507434650473) -->
    <skip />
    <string name="allow_interruption" msgid="7136150018111848721">"Dozvoli ometanja"</string>
    <string name="allow_interruption_summary" msgid="7870159391333957050">"family link da aktivira zvuk, vibrira i/ili prikaže obavještenja na ekranu"</string>
    <!-- no translation found for notification_channel_summary_min (2965790706738495761) -->
    <skip />
    <!-- no translation found for notification_channel_summary_low (250062606667099181) -->
    <skip />
    <!-- no translation found for notification_channel_summary_low_status (1151953801054796200) -->
    <skip />
    <!-- no translation found for notification_channel_summary_low_lock (3801118119803089599) -->
    <skip />
    <!-- no translation found for notification_channel_summary_low_status_lock (3400487706701402136) -->
    <skip />
    <!-- no translation found for notification_channel_summary_default (6837975360341956621) -->
    <skip />
    <!-- no translation found for notification_channel_summary_high (8779797505981599285) -->
    <skip />
    <string name="notification_switch_label" msgid="6843075654538931025">"Prikaži obavještenja"</string>
    <string name="default_notification_assistant" msgid="7631945224761430146">"Asistent za obavještenja"</string>
    <string name="notifications_sent_daily" msgid="3584506541352710975">"~<xliff:g id="NUMBER">%1$s</xliff:g> dnevno"</string>
    <string name="notifications_sent_weekly" msgid="1030525736746720584">"~<xliff:g id="NUMBER">%1$s</xliff:g> sedmično"</string>
    <string name="notifications_sent_never" msgid="1001964786456700536">"Nikada"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Pristup obavještenjima"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8748026238701253040">"Pristup obavještenjima radnog profila je blokiran"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Aplikacije ne mogu čitati obavještenja"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="7930130030691218387">
      <item quantity="one">%d aplikacija može čitati obavještenja</item>
      <item quantity="few">%d aplikacije mogu čitati obavještenja</item>
      <item quantity="other">%d aplikacija može čitati obavještenja</item>
    </plurals>
    <string name="notification_assistant_title" msgid="4788805096903794353">"Asistent za obavještenja"</string>
    <string name="no_notification_assistant" msgid="3230229194702623108">"Nema asistenta"</string>
    <string name="no_notification_listeners" msgid="3487091564454192821">"Nijedna instalirana aplikacija nije zatražila pristup obavještenjima."</string>
    <string name="notification_assistant_security_warning_title" msgid="300600401595343861">"Dozvoliti pristup obavještenjima za uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_assistant_security_warning_summary" msgid="5829972610310154776">"<xliff:g id="NOTIFICATION_ASSISTANT_NAME">%1$s</xliff:g> će moći čitati sva obavještenja, uključujući lične informacije kao što su imena kontakata i tekst primljenih poruka. Takođe će moći izmijeniti ili odbaciti obavještenja ili koristiti dugmad za radnje u obavještenjima. \n\nNa ovaj način će se aplikaciji dati i mogućnost da uključi i isključi način rada Ne ometaj te da promijeni postavke povezane s tom opcijom."</string>
    <string name="notification_listener_security_warning_title" msgid="5522924135145843279">"Želite li dozvoliti pristup obavještenjima za uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="119203147791040151">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> će moći čitati sva obavještenja, uključujući lične informacije kao što su imena kontakata i tekst primljenih poruka. Također će moći odbaciti obavještenja ili koristiti dugmad za radnje u obavještenjima. \n\nTime će se aplikaciji dati i mogućnost da uključi i isključi način rada Ne ometaj te da promijeni postavke povezane s tom opcijom."</string>
    <string name="notification_listener_disable_warning_summary" msgid="6738915379642948000">"Ako korisniku <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> isključite pristup obavještenjima, može se isključiti i pristup načinu rada Ne ometaj."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="8333442186428083057">"Isključi"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8586417377104211584">"Otkaži"</string>
    <string name="vr_listeners_title" msgid="1318901577754715777">"Usluge pomagača za VR"</string>
    <string name="no_vr_listeners" msgid="2689382881717507390">"Nijedna instalirana aplikacija nije zatražila da bude pokrenuta kao usluga pomagača za VR."</string>
    <string name="vr_listener_security_warning_title" msgid="8309673749124927122">"Želite li dozvoliti pristup VR-a za uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="6931541068825094653">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> će moći raditi kada aplikacije budete koristili u načinu rada virtuelne realnosti."</string>
    <string name="display_vr_pref_title" msgid="8104485269504335481">"Kada je uređaj u VR načinu rada"</string>
    <string name="display_vr_pref_low_persistence" msgid="5707494209944718537">"Smanjenje zamućenosti (preporučeno)"</string>
    <string name="display_vr_pref_off" msgid="2190091757123260989">"Smanjenje treperenja"</string>
    <string name="picture_in_picture_title" msgid="5824849294270017113">"Slika u slici"</string>
    <string name="picture_in_picture_empty_text" msgid="685224245260197779">"Nijedna instalirana aplikacija ne podržava način rada Slika u slici"</string>
    <string name="picture_in_picture_keywords" msgid="8361318686701764690">"sus slika u"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4080800421316791732">"Slika u slici"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="1131910667023738296">"Dozvoli način rada Slika u slici"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="1264019085827708920">"Dozvoli ovoj aplikaciji kreiranje prozora u načinu rada slika u slici dok je aplikacija otvorena ili nakon što je napustite (naprimjer, da nastavite gledati videozapis). Ovaj prozor se prikazuje preko drugih aplikacija koje koristite."</string>
    <string name="manage_zen_access_title" msgid="2611116122628520522">"Pristup načinu rada Ne ometaj"</string>
    <string name="zen_access_detail_switch" msgid="1188754646317450926">"Dozvoli način rada Ne ometaj"</string>
    <string name="zen_access_empty_text" msgid="8772967285742259540">"Nijedna instalirana aplikacija nije zatražila pristup za Ne ometaj"</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Učitavaju se aplikacije..."</string>
    <string name="app_notifications_off_desc" msgid="8289223211387083447">"Na vaš zahtjev, Android blokira pojavljivanje obavještenja iz ove aplikacije na ovom uređaju"</string>
    <string name="channel_notifications_off_desc" msgid="9013011134681491778">"Na vaš zahtjev, Android blokira pojavljivanje ove kategorije obavještenja na ovom uređaju"</string>
    <string name="channel_group_notifications_off_desc" msgid="2315252834146837470">"Na vaš zahtjev, Android blokira pojavljivanje ove grupe obavještenja na ovom uređaju"</string>
    <string name="notification_channels" msgid="5346841743182627500">"Kategorije"</string>
    <string name="notification_channels_other" msgid="5645317113885788226">"Ostalo"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="3420621520561455358">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> kategorija</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategorije</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategorija</item>
    </plurals>
    <string name="no_channels" msgid="3077375508177744586">"Ova aplikacija nije objavila nikakva obavještenja"</string>
    <string name="app_settings_link" msgid="8894946007543660906">"Dodatne postavke u aplikaciji"</string>
    <string name="app_notification_listing_summary_zero" msgid="8046168435207424440">"Uključeno za sve aplikacije"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="6709582776823665660">
      <item quantity="one">Isključeno za <xliff:g id="COUNT_1">%d</xliff:g> aplikaciju</item>
      <item quantity="few">Isključeno za <xliff:g id="COUNT_1">%d</xliff:g> aplikacije</item>
      <item quantity="other">Isključeno za <xliff:g id="COUNT_1">%d</xliff:g> aplikacija</item>
    </plurals>
    <plurals name="deleted_channels" formatted="false" msgid="8028574302599397935">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> kategorija je izbrisana</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategorije su izbrisane</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategorija je izbrisano</item>
    </plurals>
    <string name="notification_toggle_on" msgid="650145396718191048">"Uključeno"</string>
    <string name="notification_toggle_off" msgid="2142010737190671762">"Isključeno"</string>
    <string name="app_notification_block_title" msgid="4069351066849087649">"Blokiraj sve"</string>
    <string name="app_notification_block_summary" msgid="4744020456943215352">"Nikada ne prikazuj ova obavještenja"</string>
    <string name="notification_content_block_title" msgid="5854232570963006360">"Prikaži obavještenja"</string>
    <string name="notification_content_block_summary" msgid="7746185794438882389">"Nikad ne prikazuj obavještenja u nijansi ili na perifernim uređajima"</string>
    <string name="notification_badge_title" msgid="6370122441168519809">"Dozvoli tačku za obavještenja"</string>
    <string name="notification_channel_badge_title" msgid="2240827899882847087">"Prikaži tačku za obavještenja"</string>
    <string name="app_notification_override_dnd_title" msgid="7867458246395884830">"Zamijeni način rada Ne ometaj"</string>
    <string name="app_notification_override_dnd_summary" msgid="2612502099373472686">"Dozvolite da se obavještenja nastave pojavljivati kada je uključen način rada Ne ometaj"</string>
    <!-- no translation found for app_notification_visibility_override_title (3618860781666494595) -->
    <skip />
    <string name="app_notification_row_banned" msgid="5983655258784814773">"Blokirano"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Prioritetna"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Osjetljivo"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"Gotovo"</string>
    <string name="app_notification_importance_title" msgid="8002263131149345584">"Važnost"</string>
    <string name="notification_show_lights_title" msgid="7671781299688190532">"Trepćuće svjetlo"</string>
    <string name="notification_vibrate_title" msgid="1646667807969755957">"Vibracija"</string>
    <string name="notification_channel_sound_title" msgid="3899212238513507941">"Zvuk"</string>
    <string name="zen_mode_rule_delete_button" msgid="903658142711011617">"Izbriši"</string>
    <string name="zen_mode_rule_rename_button" msgid="4642843370946599164">"Promijeni naziv"</string>
    <string name="zen_mode_rule_name" msgid="5607736317244760638">"Naziv rasporeda"</string>
    <string name="zen_mode_rule_name_hint" msgid="278109122579468433">"Unesite naziv rasporeda"</string>
    <string name="zen_mode_rule_name_warning" msgid="3856485373110366912">"Naziv rasporeda se već koristi"</string>
    <string name="zen_mode_add_rule" msgid="7459154136384467057">"Dodajte još"</string>
    <string name="zen_mode_add_event_rule" msgid="4454759739839069898">"Dodajte raspored događaja"</string>
    <string name="zen_mode_add_time_rule" msgid="7890557350868257760">"Dodaj vremenski određen raspored"</string>
    <string name="zen_mode_delete_rule" msgid="8055032645990309096">"Izbriši raspored"</string>
    <string name="zen_mode_choose_rule_type" msgid="40993242338494595">"Odaberite vrstu rasporeda"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6237882294348570283">"Izbrisati pravilo “<xliff:g id="RULE">%1$s</xliff:g>”?"</string>
    <string name="zen_mode_delete_rule_button" msgid="4248741120307752294">"Izbriši"</string>
    <string name="zen_mode_rule_type_unknown" msgid="3049377282766700600">"Nepoznato"</string>
    <string name="zen_mode_app_set_behavior" msgid="1534429320064381355">"Ove postavke nije moguće sada promijeniti. Aplikacija (<xliff:g id="APP_NAME">%1$s</xliff:g>) je automatski uključila način rada Ne ometaj uz prilagođene postavke."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="2558968232814237874">"Ove postavke nije moguće sada promijeniti. Neka aplikacija je automatski uključila način rada Ne ometaj uz prilagođene postavke."</string>
    <string name="zen_mode_qs_set_behavior" msgid="6200424436456086312">"Ove postavke nije moguće sada promijeniti. Način rada Ne ometaj je ručno uključen uz prilagođene postavke."</string>
    <string name="zen_schedule_rule_type_name" msgid="6163149826036287324">"Vrijeme"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="3379499360390382259">"Automatsko pravilo postavljeno je da uključi način rada Ne ometaj za vrijeme određenih perioda"</string>
    <string name="zen_event_rule_type_name" msgid="6503468472212606158">"Događaj"</string>
    <string name="zen_event_rule_enabled_toast" msgid="6910577623330811480">"Automatsko pravilo postavljeno da se uključi način rada Ne ometaj tokom određenih događaja"</string>
    <string name="zen_mode_event_rule_calendar" msgid="8787906563769067418">"Za vrijeme događaja za"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="5135844750232403975">"Za vrijeme događaja za <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="4936646399126636358">"bilo koji kalendar"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="6590671260829837157">"Ako je odgovor <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="6485568415998569885">"Bilo koji kalendar"</string>
    <string name="zen_mode_event_rule_reply" msgid="5166322024212403739">"Ako je odgovor"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="8868873496008825961">"Da, Možda ili Bez odgovora"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="2769656565454495824">"Da ili Možda"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="1003598835878784659">"Da"</string>
    <string name="zen_mode_rule_not_found_text" msgid="8963662446092059836">"Pravilo nije pronađeno."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="976098744828219297">"Uključen način rada / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="2101201392041867409">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="3195058680641389948">"Dani"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="4954143628634166317">"Ne postoji"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="146511166522076034">"Svaki dan"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="767054141267122030">"Alarm može prekoračiti vrijeme završetka"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="1673667979187593693">"Raspored će se isključiti kada se alarm aktivira"</string>
    <string name="zen_mode_custom_behavior_title" msgid="1148856394866360783">"Ponašanje načina rada Ne ometaj"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="7750128187766412708">"Koristite zadane postavke"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="7458258833216726120">"Kreirajte prilagođene postavke za ovaj raspored"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="4070854282812755247">"Za raspored \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\""</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="summary_range_symbol_combination" msgid="5695218513421897027">"<xliff:g id="START">%1$s</xliff:g> – <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="8467306662961568656">"<xliff:g id="START">%1$s</xliff:g> do <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_calls" msgid="4769117032399813012">"Dozvoli pozive"</string>
    <string name="zen_mode_calls_title" msgid="2905770092665685857">"Pozivi"</string>
    <string name="zen_mode_calls_footer" msgid="2002070641802102110">"Da budete sigurni da čujete dozvoljene dolazne pozive, provjerite je li vaš uređaj postavljen da zvoni, vibrira ili je u tihom načinu."</string>
    <string name="zen_mode_custom_calls_footer" msgid="4764756801941329281">"Dolazni pozivi su blokirani za raspored \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\". Postavke možete podesiti da omogućite prijateljima, porodici ili drugim kontaktima da vas kontaktiraju."</string>
    <string name="zen_mode_starred_contacts_title" msgid="1848464279786960190">"Kontakti označeni zvjezdicom"</string>
    <plurals name="zen_mode_starred_contacts_summary_additional_contacts" formatted="false" msgid="500105380255018671">
      <item quantity="one">Još <xliff:g id="NUM_PEOPLE">%d</xliff:g> osoba</item>
      <item quantity="few">Još <xliff:g id="NUM_PEOPLE">%d</xliff:g> osobe</item>
      <item quantity="other">Još <xliff:g id="NUM_PEOPLE">%d</xliff:g> osoba</item>
    </plurals>
    <string name="zen_mode_messages" msgid="3463040297974005265">"Dozvoli SMS-ove"</string>
    <string name="zen_mode_messages_footer" msgid="2616568463646674149">"Da budete sigurni da čujete dozvoljene dolazne poruke, provjerite je li vaš uređaj postavljen da zvoni, vibrira ili je u tihom načinu."</string>
    <string name="zen_mode_custom_messages_footer" msgid="356699532253965350">"Dolazni SMS-ovi su blokirani za raspored \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\". Postavke možete podesiti da omogućite prijateljima, porodici ili drugim kontaktima da vas kontaktiraju."</string>
    <string name="zen_mode_messages_title" msgid="7325983674655986445">"Aplikacije za SMS, MMS i poruke"</string>
    <string name="zen_mode_from_anyone" msgid="2638322015361252161">"Od bilo koga"</string>
    <string name="zen_mode_from_contacts" msgid="2232335406106711637">"Samo od kontakata"</string>
    <string name="zen_mode_from_starred" msgid="2678345811950997027">"Samo od kontakata označenih zvjezdicom"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="4046151920710059778">"Od kontakata označenih zvjezdicom i ponovljenih pozivalaca"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="1528716671301999084">"Od kontakata i ponovljenih pozivalaca"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7105261473107715445">"Samo od ponovljenih pozivalaca"</string>
    <string name="zen_mode_from_none" msgid="8219706639954614136">"Ništa"</string>
    <string name="zen_mode_from_none_calls" msgid="7705112158761351044">"Zabrani sve pozive"</string>
    <string name="zen_mode_from_none_messages" msgid="3300937656725582608">"Zabranite sve poruke"</string>
    <string name="zen_mode_alarms" msgid="6510378757005935647">"Dozvoli alarme"</string>
    <string name="zen_mode_alarms_list" msgid="1090332840207025714">"alarmi"</string>
    <string name="zen_mode_media" msgid="4529187475698084320">"Reproduciraj zvukove medija"</string>
    <string name="zen_mode_media_list" msgid="5483540766397328038">"mediji"</string>
    <string name="zen_mode_system" msgid="236278770843463810">"Dozvoli zvukove dodira"</string>
    <string name="zen_mode_system_list" msgid="6996104733185177115">"zvuci dodira"</string>
    <string name="zen_mode_reminders" msgid="5445657061499098675">"Dozvoli podsjetnike"</string>
    <string name="zen_mode_reminders_list" msgid="2853975802240340190">"podsjetnici"</string>
    <string name="zen_mode_events" msgid="6154853744271591007">"Dozvoli događaje"</string>
    <string name="zen_mode_bypassing_apps" msgid="5493729796981237881">"Dozvolite aplikacijama da zanemaruju"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="2072590348079644482">"Izuzeci za aplikacije"</string>
    <plurals name="zen_mode_bypassing_apps_subtext" formatted="false" msgid="3726913165356014788">
      <item quantity="one">Obavještenja iz <xliff:g id="NUMBER">%1$d</xliff:g> aplikacije mogu zanemariti funkciju Ne ometaj.</item>
      <item quantity="few">Obavještenja iz <xliff:g id="NUMBER">%1$d</xliff:g> aplikacije mogu zanemariti funkciju Ne ometaj.</item>
      <item quantity="other">Obavještenja iz <xliff:g id="NUMBER">%1$d</xliff:g> aplikacija mogu zanemariti funkciju Ne ometaj.</item>
    </plurals>
    <string name="zen_mode_events_list" msgid="5571368229052715098">"događaji"</string>
    <string name="zen_mode_all_callers" msgid="2378065871253871057">"bilo ko"</string>
    <string name="zen_mode_contacts_callers" msgid="5569804103920394175">"kontakti"</string>
    <string name="zen_mode_starred_callers" msgid="1023167821338514140">"kontakti označeni zvjezdicom"</string>
    <string name="zen_mode_repeat_callers" msgid="5019521886428322131">"Ponovni pozivaoci"</string>
    <string name="zen_mode_repeat_callers_list" msgid="2529895519653237330">"ponovljeni pozivaoci"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8553876328249671783">"Dozvoli ponovne pozivaoce"</string>
    <string name="zen_mode_calls_summary_one" msgid="1711737896388108388">"Dozvolite pozive koje upućuju <xliff:g id="CALLER_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_mode_calls_summary_two" msgid="8476861928783654064">"Dozvolite pozive koje upućuju <xliff:g id="CALLER_TYPE">%1$s</xliff:g> i <xliff:g id="CALLERT_TPYE">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="239685342222975733">"Ukoliko ista osoba pozove ponovo u roku od <xliff:g id="MINUTES">%d</xliff:g> min"</string>
    <string name="zen_mode_behavior_summary_custom" msgid="168127313238020146">"Prilagođeno"</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Automatski upaliti"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Nikad"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Svaku noć"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Večeri radne sedmice"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Vrijeme početka"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Vrijeme završetka"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="4201521691238728701">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> sljedeći dan"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="2061973221027570123">"Pređi na postavku Samo alarmi na neodređeno vrijeme"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="6122003583875424601">
      <item quantity="one">Pređi na alarme samo na <xliff:g id="DURATION">%1$d</xliff:g> minutu (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">Pređi na alarme samo na <xliff:g id="DURATION">%1$d</xliff:g> minute (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Pređi na alarme samo na <xliff:g id="DURATION">%1$d</xliff:g> minuta (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_summary_alarms_only_by_hour" formatted="false" msgid="2407703455581767748">
      <item quantity="one">Pređi na alarme samo na <xliff:g id="DURATION">%1$d</xliff:g> sat do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="few">Pređi na alarme samo na <xliff:g id="DURATION">%1$d</xliff:g> sata do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="other">Pređi na alarme samo na <xliff:g id="DURATION">%1$d</xliff:g> sati do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
    </plurals>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="7465525754879341907">"Pređi na postavku Samo alarmi do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="6172985102689237703">"Promijeniti u uvijek prekini"</string>
    <string name="zen_mode_screen_on" msgid="8774571998575673502">"Kada je ekran uključen"</string>
    <string name="zen_mode_screen_on_summary" msgid="2208664848367443505">"Dopusti da se na ekranu istaknu obavještenja koja su prigušena načinom rada Ne ometaj te da prikažu ikonu na statusnoj traci"</string>
    <string name="zen_mode_screen_off" msgid="3144446765110327937">"Kada je ekran isključen"</string>
    <string name="zen_mode_screen_off_summary" msgid="7430034620565812258">"Dopustite da obavještenja koja su utišana načinom rada Ne ometaj uključe ekran i zatrepere svjetlom"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="2826121465026642017">"Dopustite da obavještenja koja su utišana načinom rada Ne ometaj uključe ekran"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Postavke za obavještenja"</string>
    <string name="suggestion_button_text" msgid="3275010948381252006">"Uredu"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Slanje informacija o uređaju"</string>
    <string name="restr_pin_enter_admin_pin" msgid="1085834515677448072">"Upišite PIN administratora"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Uključeno"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Isključeno"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Kačenje ekrana"</string>
    <string name="screen_pinning_description" msgid="1110847562111827766">"Kada je ova postavka uključena, možete upotrijebiti kačenje ekrana da trenutni ekran zadržite prikazanim dok ga ne otkačite.\n\nZa korištenje kačenja ekrana:\n\n1. Vodite računa da funkcija kačenja ekrana bude uključena\n\n2. Otvorite Pregled\n\n3. Dodirnite ikonu aplikacije na vrhu ekrana, a zatim dodirnite Zakači"</string>
    <string name="screen_pinning_unlock_pattern" msgid="8282268570060313339">"Traži uzorak za otključavanje prije poništavanja kačenja"</string>
    <string name="screen_pinning_unlock_pin" msgid="8757588350454795286">"Traži PIN prije poništavanja pribadanja"</string>
    <string name="screen_pinning_unlock_password" msgid="2514079566873826434">"Traži lozinku prije poništavanja pribadanja"</string>
    <string name="screen_pinning_unlock_none" msgid="3814188275713871856">"Zaključaj uređaj kada se ekran otkači"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2232461523882170874">"Ovim profilom za Work upravlja:"</string>
    <string name="managing_admin" msgid="8843802210377459055">"Profilom upravlja <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Eksperimentalno)"</string>
    <string name="encryption_interstitial_header" msgid="468015813904595613">"Sigurno pokretanje"</string>
    <string name="encryption_continue_button" msgid="1121880322636992402">"Nastavi"</string>
    <string name="encryption_interstitial_message_pin" msgid="2317181134653424679">"Uređaj možete dodatno zaštiti tako što ćete tražiti PIN prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme. \n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja traži PIN?"</string>
    <string name="encryption_interstitial_message_pattern" msgid="7081249914068568570">"Uređaj možete dodatno zaštiti tako što ćete tražiti unošenje uzorka prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme. \n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja traži unošenje uzorka?"</string>
    <string name="encryption_interstitial_message_password" msgid="7796567133897436443">"Uređaj možete dodatno zaštiti tako što ćete tražiti lozinku prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme. \n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja traži lozinka?"</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="4550632760119547492">"Osim korištenja otiska prsta za otključavanje, uređaj možete dodatno zaštiti zahtijevanjem unošenja PIN-a prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme. \n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja zahtijeva PIN?"</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="932184823193006087">"Osim korištenja otiska prsta za otključavanje, uređaj možete dodatno zaštiti zahtijevanjem unošenja uzorka prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme. \n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja zahtijeva unošenje uzorka?"</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="5560954719370251702">"Osim korištenja otiska prsta za otključavanje, uređaj možete dodatno zaštiti zahtijevanjem unošenja lozinke prije nego što se pokrene. Dok se uređaj ne pokrene, ne može primati pozive, poruke ili obavještenja, uključujući alarme.\n\nOvim se štite podaci na izgubljenim ili ukradenim uređajima. Želite li da se za pokretanje uređaja zahtijeva lozinka?"</string>
    <string name="encryption_interstitial_message_pin_for_face" msgid="2017438765366716760">"Osim otključavanja pomoću lica, uređaj možete dodatno zaštititi zahtjevom za unos PIN-a prije pokretanja. Dok se uređaj ne pokrene, neće se moći primati pozivi, poruke ili obavještenja, uključujući i alarme.\n\nNa ovaj način se štite podaci na izgubljenim ili ukradenim uređajima. Zahtijevati PIN za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_pattern_for_face" msgid="3551827507967661552">"Osim otključavanja pomoću lica, uređaj možete dodatno zaštititi zahtjevom za unos uzorka prije pokretanja. Dok se uređaj ne pokrene, neće se moći primati pozivi, poruke ili obavještenja, uključujući i alarme.\n\nNa ovaj način se štite podaci na izgubljenim ili ukradenim uređajima. Zahtijevati uzorak za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_password_for_face" msgid="3452793542112093614">"Osim otključavanja pomoću lica, uređaj možete dodatno zaštititi zahtjevom za unos lozinke prije pokretanja. Dok se uređaj ne pokrene, neće se moći primati pozivi, poruke ili obavještenja, uključujući i alarme.\n\nNa ovaj način se štite podaci na izgubljenim ili ukradenim uređajima. Zahtijevati lozinku za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_yes" msgid="4439509435889513411">"Da"</string>
    <string name="encryption_interstitial_no" msgid="8935031349097025137">"Ne"</string>
    <string name="restricted_true_label" msgid="4761453839409220473">"Ograničena"</string>
    <string name="restricted_false_label" msgid="3279282180297058755">"Aplikacija može koristiti bateriju u pozadini"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"Zahtijevati PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"Zahtijevati unos obrasca?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"Zahtijevati lozinku?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="7582096542997635316">"Prilikom unosa PIN-a za pokretanje uređaja, usluge za pristupačnost kao što je <xliff:g id="SERVICE">%1$s</xliff:g> još uvijek neće biti dostupne."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="2020083142199612743">"Prilikom unosa obrasca za pokretanje uređaja, usluge za pristupačnost kao što je <xliff:g id="SERVICE">%1$s</xliff:g> još uvijek neće biti dostupne."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="4155875981789127796">"Prilikom unosa lozinke za pokretanje uređaja, usluge za pristupačnost kao što je <xliff:g id="SERVICE">%1$s</xliff:g> još uvijek neće biti dostupne."</string>
    <string name="direct_boot_unaware_dialog_message" msgid="2433632805847985867">"Napomena: Ako ponovo pokrenete telefon ili postavite zaključavanje ekrana, ova se aplikacija neće moći pokrenuti dok ne otključate telefon"</string>
    <string name="imei_information_title" msgid="8499085421609752290">"Informacije za IMEI"</string>
    <string name="imei_information_summary" msgid="2074095606556565233">"Relativne informacije za IMEI"</string>
    <string name="slot_number" msgid="3762676044904653577">"(<xliff:g id="SLOT_NUM">%1$d</xliff:g>. slot)"</string>
    <string name="launch_by_default" msgid="1840761193189009248">"Zadano otvori"</string>
    <string name="app_launch_domain_links_title" msgid="1160925981363706090">"Otvaranje linkova"</string>
    <string name="app_launch_open_domain_urls_title" msgid="8914721351596745701">"Otvori podržane linkove"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="5367573364240712217">"Otvori bez pitanja"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="8250695258211477480">"Podržani linkovi"</string>
    <string name="app_launch_other_defaults_title" msgid="2516812499807835178">"Ostale zadane vrijednosti"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"<xliff:g id="SIZE">%1$s</xliff:g> se koristi u memoriji <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="6042049833565674948">"Unutrašnja pohrana"</string>
    <string name="storage_type_external" msgid="7738894330670001898">"Vanjska pohrana"</string>
    <string name="data_summary_format" msgid="6213211533341068366">"Iskorišt.: <xliff:g id="SIZE">%1$s</xliff:g> od <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="7128074132917008743">"Iskorištena memorija"</string>
    <string name="change" msgid="6657848623929839991">"Izmijeni"</string>
    <string name="change_storage" msgid="600475265207060436">"Promijeni pohranu"</string>
    <string name="notifications_label" msgid="2872668710589600731">"Obavještenja"</string>
    <string name="notifications_enabled" msgid="6983396130566021385">"Uključeno"</string>
    <string name="notifications_enabled_with_info" msgid="5669544704839269901">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g>/<xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="1262114548434938079">"Isključeno"</string>
    <string name="notifications_partly_blocked" msgid="592071133950126656">"Isključene kategorije: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="notifications_silenced" msgid="4728603513072110381">"Bez zvuka"</string>
    <string name="notifications_redacted" msgid="4493588975742803160">"Osjetljivi sadržaj nije na zaključanom ekranu."</string>
    <string name="notifications_hidden" msgid="3619610536038757468">"Ne na zaključanom ekranu"</string>
    <string name="notifications_priority" msgid="1066342037602085552">"Način rada Ne ometaj je poništen."</string>
    <string name="notifications_summary_divider" msgid="9013807608804041387">" / "</string>
    <string name="notification_summary_level" msgid="2726571692704140826">"Nivo %d"</string>
    <string name="notification_summary_channel" msgid="5831124672372023524">"<xliff:g id="CHANNEL_NAME">%1$s</xliff:g> • <xliff:g id="GROUP_NAME">%2$s</xliff:g>"</string>
    <plurals name="notifications_categories_off" formatted="false" msgid="5583365573683409754">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> kategorija isključena</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategorije isključene</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategorija isključeno</item>
    </plurals>
    <plurals name="permissions_summary" formatted="false" msgid="6402730318075959117">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> dodijeljeno odobrenje</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> dodijeljena odobrenja</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> dodijeljenih odobrenja</item>
    </plurals>
    <plurals name="runtime_permissions_summary" formatted="false" msgid="1564663886246010959">
      <item quantity="one"><xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g> odobrenja je dato</item>
      <item quantity="few"><xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g> odobrenja su data</item>
      <item quantity="other"><xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g> odobrenja je dato</item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="931276038884210752">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> dodatno odobrenje</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> dodatna odobrenje</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> dodatnih odobrenja</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="1679758182657005375">"Nema dodijeljenih odobrenja"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7655100570513818534">"Nema zatraženih odobrenja"</string>
    <string name="filter_all_apps" msgid="1988403195820688644">"Sve aplikacije"</string>
    <string name="filter_enabled_apps" msgid="5395727306799456250">"Instalirane aplikacije"</string>
    <string name="filter_instant_apps" msgid="574277769963965565">"Instant aplikacije"</string>
    <string name="filter_personal_apps" msgid="3277727374174355971">"Lične"</string>
    <string name="filter_work_apps" msgid="24519936790795574">"Work"</string>
    <string name="filter_notif_all_apps" msgid="2299049859443680242">"Aplikacije: Sve"</string>
    <string name="filter_notif_blocked_apps" msgid="3383043508771300704">"Isključeno"</string>
    <string name="filter_notif_urgent_channels" msgid="3972473613117159653">"Kategorije: hitno"</string>
    <string name="filter_notif_low_channels" msgid="4128487387390004604">"Kategorije: niska važnost"</string>
    <string name="filter_notif_blocked_channels" msgid="5880190882221644289">"Kategorije: Isključene"</string>
    <string name="filter_notif_dnd_channels" msgid="1817930848881696728">"Kategorije: Zanemaruje postavku Ne ometaj"</string>
    <string name="advanced_apps" msgid="4812975097124803873">"Napredno"</string>
    <string name="configure_apps" msgid="6685680790825882528">"Konfiguriraj aplikacije"</string>
    <string name="unknown_app" msgid="5275921288718717656">"Nepoznata aplikacija"</string>
    <string name="app_permissions" msgid="5584182129908141622">"Upravitelj odobrenja"</string>
    <string name="app_permissions_summary" msgid="5163974162150406324">"Aplikacije koje koriste: <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="tap_to_wake" msgid="7211944147196888807">"Dodirnite za buđenje"</string>
    <string name="tap_to_wake_summary" msgid="4341387904987585616">"Dva puta dodirnite bilo gdje na zaslonu da probudite uređaj"</string>
    <string name="domain_urls_title" msgid="3132983644568821250">"Otvaranje linkova"</string>
    <string name="domain_urls_summary_none" msgid="2639588015479657864">"Ne otvara podržane linkove"</string>
    <string name="domain_urls_summary_one" msgid="3704934031930978405">"Otvori <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="3950089361819428455">"Otvori <xliff:g id="DOMAIN">%s</xliff:g> i druge URL-ove"</string>
    <string name="domain_urls_apps_summary_off" msgid="1833056772600031220">"Nema aplikacija koje mogu otvoriti podržane linkove"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="240214361240709399">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aplikacija koja otvara podržane linkove</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikacije koje otvaraju podržane linkove</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacija koje otvaraju podržane linkove</item>
    </plurals>
    <string name="app_link_open_always" msgid="2474058700623948148">"Otvori u ovoj aplikaciji"</string>
    <string name="app_link_open_ask" msgid="7800878430190575991">"Pitaj svaki put"</string>
    <string name="app_link_open_never" msgid="3407647600352398543">"Nemoj otvarati u ovoj aplikaciji"</string>
    <string name="default_apps_title" msgid="1660450272764331490">"Zadano"</string>
    <string name="default_for_work" msgid="9152194239366247932">"Uobičajeno za rad"</string>
    <string name="assist_and_voice_input_title" msgid="1733165754793221197">"Pomoć i glasovni unos"</string>
    <string name="default_assist_title" msgid="8868488975409247921">"Aplikacija za pomoć"</string>
    <string name="assistant_security_warning_title" msgid="8673079231955467177">"Želite li da <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> bude vaš asistent?"</string>
    <string name="assistant_security_warning" msgid="8498726261327239136">"Asistent dobija mogućnost čitanja informacija o aplikacijama koje se koriste na vašem sistemu, uključujući informacije vidljive na ekranu ili dostupne unutar aplikacija."</string>
    <string name="assistant_security_warning_agree" msgid="7710290206928033908">"Pristajem"</string>
    <string name="assistant_security_warning_disagree" msgid="877419950830205913">"Ne slažem se"</string>
    <string name="choose_voice_input_title" msgid="975471367067718019">"Odaberite glasovni unos"</string>
    <string name="default_browser_title" msgid="8101772675085814670">"Aplikacija preglednika"</string>
    <string name="default_browser_title_none" msgid="2124785489953628553">"Nema zadanog pretraživača"</string>
    <string name="default_phone_title" msgid="282005908059637350">"Aplikacija za telefon"</string>
    <string name="roles_title" msgid="8739481762225637569">"Uloge"</string>
    <string name="default_app" msgid="6864503001385843060">"(zadano)"</string>
    <string name="system_app" msgid="9068313769550747372">"(Sistem)"</string>
    <string name="system_default_app" msgid="3091113402349739037">"(Sistemski zadano)"</string>
    <string name="apps_storage" msgid="4353308027210435513">"Pohrana aplikacija"</string>
    <string name="usage_access" msgid="5479504953931038165">"Pristup korištenju"</string>
    <string name="permit_usage_access" msgid="4012876269445832300">"Dopusti pristup korištenju"</string>
    <string name="app_usage_preference" msgid="7065701732733134991">"Postavke upotrebe aplikacija"</string>
    <string name="time_spent_in_app_pref_title" msgid="9124796405314626532">"Vrijeme upotrebe"</string>
    <string name="usage_access_description" msgid="1352111094596416795">"Pristup korištenju omogućava praćenje drugih aplikacija koje koristite i učestalosti korištenja, kao i praćenje vašeg operatera, postavke jezika i drugo."</string>
    <string name="memory_settings_title" msgid="7490541005204254222">"Memorija"</string>
    <string name="memory_details_title" msgid="8542565326053693320">"Detalji o memoriji"</string>
    <string name="always_running" msgid="6042448320077429656">"Uvijek je pokrenuta (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="6611250683037700864">"Ponekad je pokrenuta (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="348413460168817458">"Rijetko u funkciji (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="6874803757715963097">"Maksimalno"</string>
    <string name="memory_avg_use" msgid="7382015389130622870">"U prosjeku"</string>
    <string name="memory_max_desc" msgid="2861832149718335864">"Maksimalno <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="1551240906596518412">"<xliff:g id="MEMORY">%1$s</xliff:g> u proseku"</string>
    <string name="memory_use_running_format" msgid="4172488041800743760">"<xliff:g id="MEMORY">%1$s</xliff:g>/<xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="77905604092541454">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="3459065925679828230">"Optimizacija baterije"</string>
    <string name="additional_battery_info" msgid="4754099329165411970">"Obavještenja o upotrebi"</string>
    <string name="show_all_apps" msgid="1512506948197818534">"Prikaži potpuno korištenje uređaja"</string>
    <string name="hide_extra_apps" msgid="5016497281322459633">"Prikaži korištenje aplikacije"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="467347882627862744">
      <item quantity="one"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacija se ne ponaša kako treba</item>
      <item quantity="few"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacije se ne ponašaju kako treba</item>
      <item quantity="other"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacija se ne ponaša kako treba</item>
    </plurals>
    <plurals name="power_high_usage_title" formatted="false" msgid="3826660033363082922">
      <item quantity="one">Aplikacije prazne bateriju</item>
      <item quantity="few">Aplikacije prazne bateriju</item>
      <item quantity="other">Aplikacije prazne bateriju</item>
    </plurals>
    <string name="high_power_filter_on" msgid="3222265297576680099">"Bez optimizacije"</string>
    <string name="high_power_on" msgid="6216293998227583810">"Nije optimizirano"</string>
    <string name="high_power_off" msgid="3393904131961263278">"Optimizacija potrošnje baterije"</string>
    <string name="high_power_system" msgid="7362862974428225301">"Optimizacija baterije je nedostupna"</string>
    <string name="high_power_desc" msgid="6283926163708585760">"Ne primjenjuje se optimizacija baterije. Tako se baterija može brže isprazniti."</string>
    <string name="high_power_prompt_title" msgid="6358673688590282655">"Dopustiti aplikaciji da uvijek radi u pozadini?"</string>
    <string name="high_power_prompt_body" msgid="1031422980602565049">"Ako aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> dopustite da uvijek radi u pozadini, može se skratiti vijek trajanja baterije. \n\nTo možete promijeniti kasnije ako odete u Postavke &gt; Aplikacije i obavještenja."</string>
    <string name="battery_summary" msgid="8044042095190688654">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> iskorištenosti od posljednje potpune napunjenosti"</string>
    <string name="battery_power_management" msgid="5571519699679107523">"Upravljanje napajanjem"</string>
    <string name="no_battery_summary" msgid="3528036835462846814">"Nema potrošnje baterije od prošlog potpunog punjenja"</string>
    <string name="app_notification_preferences" msgid="1599319335092722613">"Postavke aplikacije"</string>
    <string name="system_ui_settings" msgid="579824306467081123">"Prikaži podešivač za SystemUI"</string>
    <string name="additional_permissions" msgid="6463784193877056080">"Dodatna odobrenja"</string>
    <string name="additional_permissions_more" msgid="3538612272673191451">"Još <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1124840737776588602">"Podijeliti izvještaj o grešci?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4973886976504823801">"Vaš IT administrator je zatražio izvještaj o grešci kako bi pomogao u rješavanju problema ovog uređaja. Može doći do dijeljenja aplikacija i podataka."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="3495929560689435496">"Vaš IT administrator je zatražio izvještaj o grešci kako bi pomogao u rješavanju problema na ovom uređaju. To može uzrokovati dijeljenje aplikacija i podataka te privremeno usporiti vaš uređaj."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="5859287696666024466">"Ovaj izvještaj o grešci se dijeli sa vašim IT administratorom. Kontaktirajte ga da dobijete više informacija."</string>
    <string name="share_remote_bugreport_action" msgid="532226159318779397">"Podijelite"</string>
    <string name="decline_remote_bugreport_action" msgid="518720235407565134">"Odbij"</string>
    <string name="usb_use_charging_only" msgid="4800495064747543954">"Nema prijenosa podataka"</string>
    <string name="usb_use_charging_only_desc" msgid="3066256793008540627">"Samo puni ovaj uređaj"</string>
    <string name="usb_use_power_only" msgid="3236391691786786070">"Punjenje povezanog uređaja"</string>
    <string name="usb_use_file_transfers" msgid="1223134119354320726">"Prijenos fajlova"</string>
    <string name="usb_use_file_transfers_desc" msgid="4235764784331804488">"Prebacite fajlove na drugi uređaj"</string>
    <string name="usb_use_photo_transfers" msgid="8192719651229326283">"PTP"</string>
    <string name="usb_use_photo_transfers_desc" msgid="2963034811151325996">"Prebacuje slike ili fajlove ukoliko MTP nije podržan (PTP)"</string>
    <string name="usb_use_tethering" msgid="3944506882789422118">"Povezivanje mobitela putem USB-a"</string>
    <string name="usb_use_MIDI" msgid="5116404702692483166">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="8473936990076693175">"Koristite uređaj u MIDI načinu"</string>
    <string name="usb_use" msgid="3372728031108932425">"Koristite USB za"</string>
    <string name="usb_default_label" msgid="2211094045594574774">"Zadana USB konfiguracija"</string>
    <string name="usb_default_info" msgid="8864535445796200695">"Kada se poveže drugi uređaj i vaš telefon je otključan, primijenit će se ove postavke. Povežite se samo s pouzdanim uređajima."</string>
    <string name="usb_pref" msgid="1400617804525116158">"USB"</string>
    <string name="usb_preference" msgid="7394265019817945275">"Postavke USB-a"</string>
    <string name="usb_control_title" msgid="4404322722995917160">"USB-om upravlja"</string>
    <string name="usb_control_host" msgid="2276710819046647200">"Povezani uređaj"</string>
    <string name="usb_control_device" msgid="5821511964163469463">"Ovaj uređaj"</string>
    <string name="usb_switching" msgid="8995313698715545619">"Prebacivanje…"</string>
    <string name="usb_switching_failed" msgid="4156073015692409651">"Prebacivanje nije uspjelo"</string>
    <string name="usb_summary_charging_only" msgid="7544327009143659751">"Punjenje ovog uređaja"</string>
    <string name="usb_summary_power_only" msgid="1996391096369798526">"Punjenje povezanog uređaja"</string>
    <string name="usb_summary_file_transfers" msgid="6925168380589489645">"Prijenos fajlova"</string>
    <string name="usb_summary_tether" msgid="951190049557074535">"Povezivanje mobitela putem USB-a"</string>
    <string name="usb_summary_photo_transfers" msgid="665584667685030007">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2399066753961085360">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="7700800611455849806">"Prijenos fajlova i napajanje"</string>
    <string name="usb_summary_tether_power" msgid="5825335393952752238">"Povezivanje mobitela putem USB-a i napajanje"</string>
    <string name="usb_summary_photo_transfers_power" msgid="6826058111908423069">"PTP i napajanje"</string>
    <string name="usb_summary_MIDI_power" msgid="3308250484012677596">"MIDI i napajanje"</string>
    <string name="background_check_pref" msgid="7550258400138010979">"Provjera u pozadini"</string>
    <string name="background_check_title" msgid="4534254315824525593">"Pun pristup pozadini"</string>
    <string name="assist_access_context_title" msgid="2269032346698890257">"Korištenje teksta s ekrana"</string>
    <string name="assist_access_context_summary" msgid="1991421283142279560">"Omogućava aplikaciji za pomoć da pristupa sadržaju na ekranu kao tekstu"</string>
    <string name="assist_access_screenshot_title" msgid="4034721336291215819">"Korištenje snimke ekrana"</string>
    <string name="assist_access_screenshot_summary" msgid="6761636689013259901">"Omogućava aplikaciji za pomoć da pristupa slici ekrana"</string>
    <string name="assist_flash_title" msgid="506661221230034891">"Bljeskanje ekrana"</string>
    <string name="assist_flash_summary" msgid="9160668468824099262">"Ivice ekrana bljeskaju kada aplikacija za pomoć pristupi tekstu s ekrana ili snimku ekrana"</string>
    <string name="assist_footer" msgid="1982791172085896864">"Aplikacije za pomoć vam mogu pomoći na osnovu informacija s ekrana koji pregledate. Kako bi vam pružile sveukupnu pomoć, neke aplikacije podržavaju i usluge pokretača i glasovnog unosa."</string>
    <string name="average_memory_use" msgid="829566450150198512">"Prosječna iskorištenost memorije"</string>
    <string name="maximum_memory_use" msgid="7493720799710132496">"Maksimalna upotreba memorije"</string>
    <string name="memory_usage" msgid="1781358557214390033">"Korištenje memorije"</string>
    <string name="app_list_memory_use" msgid="6987417883876419338">"Korištenje aplikacija"</string>
    <string name="memory_details" msgid="5943436005716991782">"Detalji"</string>
    <string name="memory_use_summary" msgid="5608257211903075754">"<xliff:g id="SIZE">%1$s</xliff:g> memorije korišteno u prosjeku u zadnja 3 sata"</string>
    <string name="no_memory_use_summary" msgid="2016900536806235588">"Nikakva memorija se ne koristi u posljednja tri sata"</string>
    <string name="sort_avg_use" msgid="3998036180505143129">"Poredaj po prosječnoj upotrebi"</string>
    <string name="sort_max_use" msgid="4629247978290075124">"Poredaj po maksimalnom korištenju"</string>
    <string name="memory_performance" msgid="5661005192284103281">"Performanse"</string>
    <string name="total_memory" msgid="2017287600738630165">"Ukupno memorije"</string>
    <string name="average_used" msgid="5338339266517245782">"Prosječna iskorištenost (%)"</string>
    <string name="free_memory" msgid="4003936141603549746">"Slobodno"</string>
    <string name="memory_usage_apps" msgid="5650192998273294098">"Memorija koju koriste aplikacije"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="6089210945574265774">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija je koristila memoriju u prethodnom periodu od <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikacije su koristile memoriju u prethodnom periodu od <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija je koristilo memoriju u prethodnom periodu od <xliff:g id="DURATION_1">%2$s</xliff:g></item>
    </plurals>
    <string name="running_frequency" msgid="6622624669948277693">"Frekvencija"</string>
    <string name="memory_maximum_usage" msgid="6513785462055278341">"Maksimalno korištenje"</string>
    <string name="no_data_usage" msgid="9131454024293628063">"Nema korištenja podataka"</string>
    <string name="zen_access_warning_dialog_title" msgid="1198189958031157142">"Dozvoliti da <xliff:g id="APP">%1$s</xliff:g> pristupa načinu rada Ne ometaj?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="4015885767653010873">"Aplikacija će biti u mogućnosti da uključi/isključi način rada Ne ometaj i da izmijeni povezane postavke."</string>
    <string name="zen_access_disabled_package_warning" msgid="302820100078584431">"Mora ostati uključeno jer je uključen pristup obavještenjima"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="558779234015793950">"Opozvati pristup ka usluzi Ne ometaj za aplikaciju <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="5518216907304930148">"Sva pravila za uslugu Ne ometaj koje je kreirala ova aplikacija, biti će uklonjena."</string>
    <string name="ignore_optimizations_on" msgid="6915689518016285116">"Ne optimiziraj"</string>
    <string name="ignore_optimizations_off" msgid="6153196256410296835">"Optimizuj"</string>
    <string name="ignore_optimizations_on_desc" msgid="3549930955839111652">"Baterija se može brže isprazniti. Aplikaciji više neće biti ograničena potrošnja baterije u pozadini."</string>
    <string name="ignore_optimizations_off_desc" msgid="5255731062045426544">"Preporučuje se za duže trajanje baterije"</string>
    <string name="ignore_optimizations_title" msgid="2829637961185027768">"Želite da dozvolite aplikaciji <xliff:g id="APP">%s</xliff:g> da ignoriše optimizacije baterije?"</string>
    <string name="app_list_preference_none" msgid="108006867520327904">"Nijedno"</string>
    <string name="work_profile_usage_access_warning" msgid="2918050775124911939">"Isključivanjem pristupa korištenju za ovu aplikaciju nećete spriječiti administratora da prati podatke o korištenju u aplikacija u vašem radnom profilu."</string>
    <string name="accessibility_lock_screen_progress" msgid="2408292742980383166">"Iskorištenih znakova: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="draw_overlay" msgid="6564116025404257047">"Prikaz preko drugih aplikacija"</string>
    <string name="system_alert_window_settings" msgid="8466613169103527868">"Prikaz preko drugih aplikacija"</string>
    <string name="system_alert_window_apps_title" msgid="7005760279028569491">"Aplikacije"</string>
    <string name="system_alert_window_access_title" msgid="6297115362542361241">"Prikaz preko drugih aplikacija"</string>
    <string name="permit_draw_overlay" msgid="7456536798718633432">"Dozvoli prikaz preko drugih aplikacija"</string>
    <string name="allow_overlay_description" msgid="8961670023925421358">"Dozvolite ovoj aplikaciji da prekrije ostale aplikacije koje koristite. Može vas ometati u korištenju tih aplikacija ili promijeniti način na koji se one prikazuju ili ponašaju."</string>
    <string name="keywords_vr_listener" msgid="7441221822576384680">"vr slušalac virtuelne realnosti stereo pomoćna usluga"</string>
    <string name="keywords_system_alert_window" msgid="5049498015597864850">"sistem upozorenje prozor dijaloški okvir prikazivanje preko drugih aplikacija"</string>
    <string name="overlay_settings" msgid="6930854109449524280">"Prikaz preko drugih aplikacija"</string>
    <string name="system_alert_window_summary" msgid="602892301318324492">"Aplikacije s odobrenjem za prikaz preko drugih aplikacija: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="filter_overlay_apps" msgid="6965969283342557573">"Aplikacije s odobrenjem"</string>
    <string name="app_permission_summary_allowed" msgid="1505409933012886711">"Dozvoljeno"</string>
    <string name="app_permission_summary_not_allowed" msgid="2592617058101882802">"Nije dozvoljeno"</string>
    <string name="keywords_install_other_apps" msgid="761078076051006558">"instaliranje aplikacije nepoznati izvori"</string>
    <string name="write_settings" msgid="4797457275727195681">"Izmjena postavki sistema"</string>
    <string name="keywords_write_settings" msgid="6415597272561105138">"pisati izmijeniti sistemske postavke"</string>
    <string name="write_settings_summary" msgid="4302268998611412696">"Aplikacije sa odobrenjem za mijenjanje postavki sistema: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="financial_apps_sms_access_title" msgid="762694352017728050">"Pristup SMS-ovima za finansijske aplikacije"</string>
    <string name="filter_install_sources_apps" msgid="3102976274848199118">"Mogu instalirati druge aplikacije"</string>
    <string name="filter_write_settings_apps" msgid="2914615026197322551">"Mogu mijenjati postavke sistema"</string>
    <string name="write_settings_title" msgid="4232152481902542284">"Mogu mijenjati postavke sistema"</string>
    <string name="write_system_settings" msgid="3482913590601096763">"Izmjeni postavke sistema"</string>
    <string name="permit_write_settings" msgid="658555006453212691">"Dozvoli izmjenu postavki sistema"</string>
    <string name="write_settings_description" msgid="6868293938839954623">"Ovo odobrenje omogućava aplikaciji da izmijeni postavke sistema."</string>
    <string name="write_settings_on" msgid="8230580416068832239">"Da"</string>
    <string name="write_settings_off" msgid="5156104383386336233">"Ne"</string>
    <string name="external_source_switch_title" msgid="3621381992793251070">"Dozvoli iz ovog izvora"</string>
    <string name="camera_gesture_title" msgid="1075838577642393011">"Dvostruko uvrtanje za otvaranje kamere"</string>
    <string name="camera_gesture_desc" msgid="1831390075255870960">"Da biste otvorili aplikaciju za kameru, dva puta uvrnite zglob"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="1651873760405034645">"Dva pritiska na napajanje za kameru"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="7355664631775680376">"Brzo otvaranje fotoaparata bez otključavanja ekrana"</string>
    <string name="screen_zoom_title" msgid="5233515303733473927">"Veličina prikaza"</string>
    <string name="screen_zoom_short_summary" msgid="7291960817349834688">"Povećavanje ili umanjivanje objekata na ekranu"</string>
    <string name="screen_zoom_keywords" msgid="9176477565403352552">"gustoća prikaza, uvećanje ekrana, promijeni veličinu, mijenjanje veličine"</string>
    <string name="screen_zoom_summary" msgid="6445488991799015407">"Smanjite ili povećajte objekte na ekranu. Neke aplikacije s vašeg ekrana mogu promijeniti svoj položaj."</string>
    <string name="screen_zoom_preview_title" msgid="4680671508172336572">"Pregled"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="4622359904253364742">"Smanji"</string>
    <string name="screen_zoom_make_larger_desc" msgid="2236171043607896594">"Povećaj"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="8443032489384985820">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="998709701837681129">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="6546951024984852686">"Zdravo, Adi!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6935424214137738647">"Hej, želiš li da danas popijemo kafu i ispričamo se?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="5218221201861387402">"Može, super. Znam jedno dobro mjesto u blizini."</string>
    <string name="screen_zoom_conversation_message_4" msgid="5564676794767555447">"Savršeno!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="7453710416319650556">"Uto 18:00"</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="7107225702890747588">"Uto 18:01"</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="3785674344762707688">"Uto 18:02"</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2511469395448561259">"Uto 18:03"</string>
    <string name="disconnected" msgid="4836600637485526329">"Nije povezano"</string>
    <string name="keyboard_disconnected" msgid="1495037256967224035">"Nije povezano"</string>
    <string name="data_usage_summary_format" msgid="7507047900192160585">"Iskorišteno <xliff:g id="AMOUNT">%1$s</xliff:g> podataka"</string>
    <string name="data_usage_wifi_format" msgid="5417296451392612860">"<xliff:g id="AMOUNT">^1</xliff:g> iskorišteno na WiFi mreži"</string>
    <plurals name="notification_summary" formatted="false" msgid="3941492005316143599">
      <item quantity="one">Isključeno za <xliff:g id="COUNT">%d</xliff:g> aplikaciju</item>
      <item quantity="few">Isključeno za <xliff:g id="COUNT">%d</xliff:g> aplikacije</item>
      <item quantity="other">Isključeno za <xliff:g id="COUNT">%d</xliff:g> aplikacija</item>
    </plurals>
    <string name="notification_summary_none" msgid="4586376436702610">"Uključeno za sve aplikacije"</string>
    <string name="apps_summary" msgid="193158055537070092">"Broj instaliranih aplikacija: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="apps_summary_example" msgid="2118896966712746139">"24 aplikacije instalirane"</string>
    <string name="storage_summary" msgid="3801281635351732202">"Iskorišteno <xliff:g id="PERCENTAGE">%1$s</xliff:g> - Slobodno <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="storage_summary_with_sdcard" msgid="3290457009629490121">"Unutrašnja pohrana: iskorišteno <xliff:g id="PERCENTAGE">%1$s</xliff:g> - slobodno <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="display_summary" msgid="6737806235882127328">"Stanje mirovanja nakon <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neaktivnosti"</string>
    <string name="display_dashboard_summary" msgid="4145888780290131488">"Pozadinska slika, mirovanje, veličina fonta"</string>
    <string name="display_dashboard_summary_with_style" msgid="870920274423314524">"Stilovi, pozadinske slike, istek vremena ekrana, veličina fonta"</string>
    <string name="display_dashboard_nowallpaper_summary" msgid="7840559323355210111">"Stanje mirovanja, veličina slova"</string>
    <string name="display_summary_example" msgid="9102633726811090523">"Pokreni stanje mirovanja nakon 10 minuta neaktivnosti"</string>
    <string name="memory_summary" msgid="8080825904671961872">"Iskorišteno prosječno <xliff:g id="USED_MEMORY">%1$s</xliff:g> od ukupno <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="1674864467098487328">"Prijavljeni ste kao <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="3472482669588561110">"<xliff:g id="APP_NAME">%1$s</xliff:g> je zadana aplikacija"</string>
    <string name="backup_disabled" msgid="485189128759595412">"Izrada sigurnosnih kopija je onemogućena"</string>
    <string name="android_version_summary" msgid="2935995161657697278">"Ažurirano na Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="487831391976523090">"Dostupno je ažuriranje"</string>
    <string name="disabled_by_policy_title" msgid="627023216027648534">"Radnja nije dozvoljena"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="3208724801293696486">"Nije moguće promijeniti jačinu zvuka"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="7919816644946067058">"Pozivanje nije dozvoljeno"</string>
    <string name="disabled_by_policy_title_sms" msgid="5733307423899610340">"SMS poruka nije dozvoljena"</string>
    <string name="disabled_by_policy_title_camera" msgid="6225008536855644874">"Kamera nije dozvoljena"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="4066913623298047094">"Snimak ekrana nije dozvoljen"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="7872038990805477554">"Nije moguće otvoriti aplikaciju"</string>
    <string name="default_admin_support_msg" msgid="4489678214035485367">"Ukoliko imate pitanja, kontaktirajte svog IT administratora"</string>
    <string name="admin_support_more_info" msgid="8901377038510512654">"Više detalja"</string>
    <string name="admin_profile_owner_message" msgid="5860816886981109626">"Vaš administrator može pratiti i upravljati aplikacijama i podacima povezanim s vašim radnim profilom, uključujući postavke, odobrenja, korporativni pristup, aktivnost na mreži i informacije o lokaciji uređaja."</string>
    <string name="admin_profile_owner_user_message" msgid="3842630535450382172">"Vaš administrator može pratiti i upravljati aplikacijama i podacima koji su povezani s ovim korisnikom, uključujući postavke, odobrenja, korporativni pristup, aktivnost na mreži i informacije o lokaciji uređaja."</string>
    <string name="admin_device_owner_message" msgid="6232893638259790789">"Vaš administrator može pratiti i upravljati aplikacijama i podacima koji su povezani s ovim uređajem, uključujući postavke, odobrenja, korporativni pristup, aktivnost na mreži i informacije o lokaciji uređaja."</string>
    <string name="condition_turn_off" msgid="1960945836880080298">"Isključi"</string>
    <string name="condition_turn_on" msgid="9089876276117874591">"Uključi"</string>
    <string name="condition_expand_show" msgid="608202020023489939">"Prikaži"</string>
    <string name="condition_expand_hide" msgid="948507739223760667">"Sakrij"</string>
    <string name="condition_hotspot_title" msgid="5959815393203320845">"Pristupna tačka je aktivna"</string>
    <string name="condition_airplane_title" msgid="287356299107070503">"Airplane način rada je uključen"</string>
    <string name="condition_airplane_summary" msgid="2500054042183138980">"Mreže nisu dostupne"</string>
    <string name="condition_zen_title" msgid="2897779738211625">"Uključen način rada Ne ometaj"</string>
    <string name="condition_zen_summary_phone_muted" msgid="3644614024467141806">"Zvuk na telefonu je isključen"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="4047564276599301064">"S izuzecima"</string>
    <string name="condition_battery_title" msgid="3272131008388575349">"Čuvar baterije je uključen"</string>
    <string name="condition_battery_summary" msgid="5847532902924566572">"Funkcije su ograničene"</string>
    <string name="condition_cellular_title" msgid="1327317003797575735">"Prijenos podataka na mobilnoj mreži je isključen"</string>
    <string name="condition_cellular_summary" msgid="816822977403022625">"Internet je dostupan samo putem WiFi mreže"</string>
    <string name="condition_bg_data_title" msgid="5475793236997935138">"Ušteda podataka"</string>
    <string name="condition_bg_data_summary" msgid="1852811387315557164">"Funkcije su ograničene"</string>
    <string name="condition_work_title" msgid="7293722361184366648">"Radni profil je isključen"</string>
    <string name="condition_work_summary" msgid="9167580982244020746">"Za aplikacije i obavještenja"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4930240942726349213">"Uključi zvuk"</string>
    <string name="condition_device_muted_title" msgid="3476439379918599716">"Zvuk zvona je isključen"</string>
    <string name="condition_device_muted_summary" msgid="6313274406443663781">"Za pozive i obavještenja"</string>
    <string name="condition_device_vibrate_title" msgid="8070177546359590131">"Samo vibracija"</string>
    <string name="condition_device_vibrate_summary" msgid="5743200564646910423">"Za pozive i obavještenja"</string>
    <string name="night_display_suggestion_title" msgid="6602129097059325291">"Postavite plan za Noćno svjetlo"</string>
    <string name="night_display_suggestion_summary" msgid="228346372178218442">"Automatski oboji ekran svaku noć"</string>
    <string name="condition_night_display_title" msgid="5599814941976856183">"Noćno svjetlo je uključeno"</string>
    <string name="condition_night_display_summary" msgid="7150932917610919907">"Ekran ima žutu nijansu"</string>
    <string name="condition_grayscale_title" msgid="3426050703427823519">"Nijanse sive"</string>
    <string name="condition_grayscale_summary" msgid="7652835784223724625">"Prikaži samo u sivoj boji"</string>
    <string name="homepage_condition_footer_content_description" msgid="2335918927419018030">"Suzi"</string>
    <string name="suggestions_title_v2" msgid="5601181602924147569">"Prijedlozi za vas"</string>
    <string name="suggestions_title" msgid="7280792342273268377">"Prijedlozi"</string>
    <string name="suggestions_summary" msgid="2509040178581728056">"još <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="8223690393059519879">"Još <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="1857433444865249823">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> prijedlog</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> prijedloga</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> prijedloga</item>
    </plurals>
    <plurals name="suggestions_collapsed_summary" formatted="false" msgid="7680263825371165461">
      <item quantity="one">još <xliff:g id="COUNT">%1$d</xliff:g> prijedlog</item>
      <item quantity="few">još <xliff:g id="COUNT">%1$d</xliff:g> prijedloga</item>
      <item quantity="other">još <xliff:g id="COUNT">%1$d</xliff:g> prijedloga</item>
    </plurals>
    <string name="suggestion_remove" msgid="904627293892092439">"Ukloni"</string>
    <string name="color_temperature" msgid="2070126836910615605">"Hladna temperatura boje"</string>
    <string name="color_temperature_desc" msgid="4793729830226404052">"Koristite hladnije boje prikaza"</string>
    <string name="color_temperature_toast" msgid="4974218172133854827">"Isključite ekran kako biste primijenili promjenu boje"</string>
    <string name="camera_laser_sensor_switch" msgid="8913588990743234440">"Laserski senzor kamere"</string>
    <string name="ota_disable_automatic_update" msgid="2319639631655915050">"Automatska ažuriranja sistema"</string>
    <string name="ota_disable_automatic_update_summary" msgid="940729694354373087">"Ažuriranje nakon što se uređaj ponovo pokrene"</string>
    <string name="usage" msgid="2977875522080448986">"Potrošnja"</string>
    <string name="cellular_data_usage" msgid="2155683719898158203">"Prijenos podataka na mobilnoj mreži"</string>
    <string name="app_cellular_data_usage" msgid="5468472735806533448">"Prijenos podataka u aplikaciji"</string>
    <string name="wifi_data_usage" msgid="771603760674507659">"Potrošnja WiFi podataka"</string>
    <string name="ethernet_data_usage" msgid="5108764537574354616">"Prijenos podataka putem Etherneta"</string>
    <string name="wifi" msgid="1081550856200013637">"WiFi"</string>
    <string name="ethernet" msgid="6600095783781389720">"Ethernet"</string>
    <string name="cell_data_template" msgid="405684854174361041">"<xliff:g id="AMOUNT">^1</xliff:g> putem prijenosa podataka"</string>
    <string name="wifi_data_template" msgid="6265570748799357386">"<xliff:g id="AMOUNT">^1</xliff:g> WiFi podataka"</string>
    <string name="ethernet_data_template" msgid="5782476509881033590">"<xliff:g id="AMOUNT">^1</xliff:g> ethernet podataka"</string>
    <string name="billing_cycle" msgid="6614597736285325497">"Upozorenje o podacima i ograničenje"</string>
    <string name="app_usage_cycle" msgid="8877223251648092131">"Ciklus prijenosa podataka u aplikaciji"</string>
    <string name="cell_data_warning" msgid="1985956818884847057">"Upozorenje o prijenosu podataka: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="1578367585799358854">"Ograničenje prijenosa podataka: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="6888825370687743208">"Upozorenje o prijenosu podataka: <xliff:g id="ID_1">^1</xliff:g> / Ograničenje prijenosa podataka: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="billing_cycle_fragment_summary" msgid="8231066353654583106">"Mjesečno, na dan: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="network_restrictions" msgid="8234695294536675380">"Mrežna ograničenja"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="4301618027244595839">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> ograničenje</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> ograničenja</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> ograničenja</item>
    </plurals>
    <string name="operator_warning" msgid="1862988028996859195">"Obračun podataka koji vrši operater se može razlikovati od obračuna koji vrši uređaj."</string>
    <string name="data_used_template" msgid="3245919669966296505">"Iskorišteno je <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="6115364758236594593">"Postavi upozorenje o potrošnji"</string>
    <string name="data_warning" msgid="209133958008062117">"Upozorenje o podacima"</string>
    <string name="data_warning_footnote" msgid="776341964125603711">"Uređaj mjeri upozorenje o prijenosu podataka i ograničenje prijenosa podataka. Ovo se može razlikovati od prijenosa podataka kojeg je izmjerio mobilni operater."</string>
    <string name="set_data_limit" msgid="2901526323210516923">"Postavi ograničenje potrošnje"</string>
    <string name="data_limit" msgid="1885406964934590552">"Ograničenje za podatke"</string>
    <string name="data_usage_template" msgid="2923744765873163859">"<xliff:g id="ID_1">%1$s</xliff:g> iskorišteno <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1029654422228677273">"Konfiguracija"</string>
    <string name="data_usage_other_apps" msgid="3272872663517382050">"Ostale aplikacije uključene u korištenje"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="2635267833484232703">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija smije upotrebljavati neograničen prijenos podataka kada je Ušteda podataka uključena</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikacije smiju upotrebljavati neograničen prijenos podataka kada je Ušteda podataka uključena</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija smije upotrebljavati neograničen prijenos podataka kada je Ušteda podataka uključena</item>
    </plurals>
    <string name="data_usage_title" msgid="3659356290392241789">"Primarni plan prijenosa podataka"</string>
    <string name="data_usage_wifi_title" msgid="7063659423081820720">"Wi‑Fi podaci"</string>
    <string name="data_used" msgid="5116389957228457203">"Iskorišteno je <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_used_formatted" msgid="2989129931961311051">"Iskorišteno je <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="1134445012475270295">"Prekoračenje: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="8998091725895502181">"Još <xliff:g id="ID_1">^1</xliff:g>"</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="456503215317213651">
      <item quantity="one">Još %d dan</item>
      <item quantity="few">Još %d dana</item>
      <item quantity="other">Još %d dana</item>
    </plurals>
    <string name="billing_cycle_none_left" msgid="5892754995098583472">"Nema preostalog vremena"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="825838050296069404">"Preostalo je manje od 1 dana"</string>
    <string name="carrier_and_update_text" msgid="7963409972475063897">"Ažurirao mob. operater <xliff:g id="ID_1">^1</xliff:g> prije <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="3277403390316201982">"Ažurirano prije <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="4057997726060106722">"Upravo ažurirao mob. operater <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="1766859656868932996">"Upravo ažurirano"</string>
    <string name="launch_mdp_app_text" msgid="6751296320061773169">"Pogledaj plan"</string>
    <string name="launch_wifi_text" msgid="2311424914664372687">"Prikaži detalje"</string>
    <string name="data_saver_title" msgid="8034286939200289826">"Ušteda podataka"</string>
    <string name="unrestricted_data_saver" msgid="952796077540228711">"Neograničen prijenos podataka"</string>
    <string name="restrict_background_blacklisted" msgid="3995443391711013068">"Pozadinski podaci su isključeni"</string>
    <string name="data_saver_on" msgid="6774217590237934709">"Uključeno"</string>
    <string name="data_saver_off" msgid="6892309031162738794">"Isključeno"</string>
    <string name="data_saver_switch_title" msgid="836312690356005669">"Koristi funkciju Ušteda podataka"</string>
    <string name="unrestricted_app_title" msgid="4465437191723332066">"Neograničen prijenos podataka"</string>
    <string name="unrestricted_app_summary" msgid="6458008993501723912">"Dozvolite neograničen pristup podacima kada je Ušteda podataka uključena"</string>
    <string name="home_app" msgid="4066188520886810030">"Aplikacija na početnom ekranu"</string>
    <string name="no_default_home" msgid="7184117487704520238">"Nema zadane početne aplikacije"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="3832020101401318248">"Sigurno pokretanje"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="7873036097628404476">"Zahtijeva uzorak za pokretanje vašeg uređaja. Dok je isključen, ovaj uređaj ne može primati pozive, poruke, obavijesti ili alarme."</string>
    <string name="lockpattern_settings_require_pin_before_startup_summary" msgid="6022831284097476933">"Zahtijeva PIN za pokretanje vašeg uređaja. Dok je isključen, ovaj uređaj ne može primati pozive, poruke, obavijesti ili alarme."</string>
    <string name="lockpattern_settings_require_password_before_startup_summary" msgid="6818285221244966231">"Zahtijeva lozinku za pokretanje vašeg uređaja. Dok je isključen, ovaj uređaj ne može primati pozive, poruke, obavijesti ili alarme."</string>
    <string name="suggestion_additional_fingerprints" msgid="2214281455363797037">"Dodajte još jedan otisak prsta"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="5471253233176471245">"Otključajte nekim drugim prstom"</string>
    <string name="battery_saver_on_summary" msgid="7722791295871319534">"Uključeno"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="3953785517002197881">"Uključit će se na <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="784360321235698247">"Isključeno"</string>
    <string name="battery_saver_button_turn_on" msgid="3699954061337848832">"Uključi sada"</string>
    <string name="battery_saver_button_turn_off" msgid="5916996792004611890">"Isključi sada"</string>
    <string name="not_battery_optimizing" msgid="5362861851864837617">"Aplikacija ne koristiti optimizaciju baterije"</string>
    <string name="lockscreen_remote_input" msgid="969871538778211843">"Ako je uređaj zaključan, spriječiti kucanje odgovora ili drugog teksta u obavijestima"</string>
    <string name="default_spell_checker" msgid="8506899870026026660">"Zadani kontrolor pravopisa"</string>
    <string name="choose_spell_checker" msgid="6596539862291699367">"Odaberite provjeru pravopisa"</string>
    <string name="spell_checker_master_switch_title" msgid="8763132750954344372">"Koristi provjeru pravopisa"</string>
    <string name="spell_checker_not_selected" msgid="8871083796179200696">"Nije odabrano"</string>
    <string name="notification_log_no_title" msgid="5678029849672024215">"(ništa)"</string>
    <string name="notification_log_details_delimiter" msgid="3116559361552416747">": "</string>
    <string name="notification_log_details_package" msgid="2596495677039100284">"pkg"</string>
    <string name="notification_log_details_key" msgid="2995791937075862968">"ključ"</string>
    <string name="notification_log_details_group" msgid="2430467015200368698">"grupa"</string>
    <string name="notification_log_details_group_summary" msgid="7945543958255585829">"(sažetak)"</string>
    <string name="notification_log_details_visibility" msgid="2552873780715930971">"vidljivost"</string>
    <string name="notification_log_details_public_version" msgid="4247242364605495240">"javnaVerzija"</string>
    <string name="notification_log_details_priority" msgid="8371354971235991398">"prioritet"</string>
    <string name="notification_log_details_importance" msgid="2153168790791683139">"važnost"</string>
    <string name="notification_log_details_explanation" msgid="1914295130775393551">"objašnjenje"</string>
    <string name="notification_log_details_badge" msgid="3258183328267662285">"može prikazati značku"</string>
    <string name="notification_log_details_content_intent" msgid="1113554570409128083">"namjera"</string>
    <string name="notification_log_details_delete_intent" msgid="905118520685297007">"izbrisati namjeru"</string>
    <string name="notification_log_details_full_screen_intent" msgid="7118560817013522978">"namjera za cijeli ekran"</string>
    <string name="notification_log_details_actions" msgid="242523930165118066">"akcije"</string>
    <string name="notification_log_details_title" msgid="7177091647508863295">"naslov"</string>
    <string name="notification_log_details_remoteinput" msgid="8328591329858827409">"daljinski unosi"</string>
    <string name="notification_log_details_content_view" msgid="6638731378278561786">"prilagođeni prikaz"</string>
    <string name="notification_log_details_extras" msgid="4188418723779942047">"dodaci"</string>
    <string name="notification_log_details_icon" msgid="8939114059726188218">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="243148037601903212">"veličina paketa"</string>
    <string name="notification_log_details_ashmem" msgid="7241814108477320636">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="6622944771989529320">"izdato obavještenje"</string>
    <string name="notification_log_details_sound" msgid="5506232879598808099">"zvuk"</string>
    <string name="notification_log_details_vibrate" msgid="6890065466625335940">"vibracija"</string>
    <string name="notification_log_details_vibrate_pattern" msgid="6076984056201975221">"uzorak"</string>
    <string name="notification_log_details_default" msgid="2345249399796730861">"standardno/default"</string>
    <string name="notification_log_details_none" msgid="184131801230614059">"ništa"</string>
    <string name="notification_log_details_ranking_null" msgid="244660392058720919">"Rangirani objekt nedostaje."</string>
    <string name="notification_log_details_ranking_none" msgid="599607025882587844">"Rangirani objekt ne sadrži ovu tipku."</string>
    <string name="theme_customization_category" msgid="1049181544004163283">"Prilagođavanje teme"</string>
    <string name="theme_customization_accent_color_title" msgid="2946868019715911717">"Boja za isticanje"</string>
    <string name="theme_customization_font_title" msgid="1634160034866477544">"Font naslova/sadržaja"</string>
    <string name="theme_customization_icon_shape_title" msgid="9168569756271940841">"Oblik ikone"</string>
    <string name="theme_customization_device_default" msgid="5058147707906551368">"Zadana postavka uređaja"</string>
    <string name="display_cutout_emulation" msgid="7466869822418376317">"Urez u ekranu"</string>
    <string name="display_cutout_emulation_keywords" msgid="4495418317471622562">"urez ekrana, urez"</string>
    <string name="overlay_option_device_default" msgid="294510212512203638">"Zadana postavka uređaja"</string>
    <string name="overlay_toast_failed_to_apply" msgid="3506731619973103346">"Primjena preklapanja nije uspjela"</string>
    <string name="special_access" msgid="3458780842491881155">"Poseban pristup aplikacijama"</string>
    <plurals name="special_access_summary" formatted="false" msgid="260765309935675867">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aplikacija može koristiti neograničen prijenos podataka</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikacije mogu koristiti neograničen prijenos podataka</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacija može koristiti neograničen prijenos podataka</item>
    </plurals>
    <string name="special_access_more" msgid="6927066457969301921">"Prikaži više"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="1487005506049137659">"Zaista želite izbrisati korisničke podatke i pretvoriti u šifrirani fajl?"</string>
    <string name="button_confirm_convert_fbe" msgid="7101855374850373091">"Obriši i pretvori"</string>
    <string name="reset_shortcut_manager_throttling" msgid="6495066467198668994">"Poništi ograničenje brzine ShortcutManagera"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="1826770872063707900">"Ograničenje brzine ShortcutManagera je poništeno"</string>
    <string name="notification_suggestion_title" msgid="387052719462473500">"Kontrolirajte informacije na zaključanom ekranu"</string>
    <string name="notification_suggestion_summary" msgid="8521159741445416875">"Pokaži ili sakrij sadržaj obavještenja"</string>
    <string name="page_tab_title_summary" msgid="4070309266374993258">"Sve"</string>
    <string name="page_tab_title_support" msgid="4407600495101788249">"Savjeti i podrška"</string>
    <string name="developer_smallest_width" msgid="7516950434587313360">"Najmanja širina"</string>
    <string name="premium_sms_none" msgid="8268105565738040566">"Nijedna instalirana aplikacija nije zatražila pristup premijum SMS-ovima"</string>
    <string name="premium_sms_warning" msgid="9086859595338944882">"Usluga Premium SMS se možda dodatno plaća te će trošak biti na računu koji dobijate od operatera. Ukoliko aplikaciji date odobrenje, moći ćete slati premium SMS poruke putem te aplikacije."</string>
    <string name="premium_sms_access" msgid="4660047004791638305">"Pristup premijum SMS-ovima"</string>
    <string name="bluetooth_disabled" msgid="6244000672828617410">"Isključeno"</string>
    <string name="bluetooth_connected_summary" msgid="7672528674593152862">"Povezan s uređajem <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="9173661896296663932">"Povezan s više uređaja"</string>
    <string name="demo_mode" msgid="2798762752209330277">"Način demonstracije Sistemskog UI-a"</string>
    <string name="dark_ui_mode" msgid="3888371857083890543">"Tema po mraku"</string>
    <string name="dark_ui_settings_dark_summary" msgid="8205234847639399279">"Podržane aplikacije će se također prebaciti na tamnu temu"</string>
    <string name="dark_ui_settings_dialog_acknowledge" msgid="8683868642329596059">"Razumijem"</string>
    <string name="quick_settings_developer_tiles" msgid="5947788063262762448">"Pločice programera za brze postavke"</string>
    <string name="winscope_trace_quick_settings_title" msgid="1294290008255732032">"Winscope praćenje"</string>
    <string name="sensors_off_quick_settings_title" msgid="1487323753632515801">"Senzori su isključeni"</string>
    <string name="managed_profile_settings_title" msgid="2729481936758125054">"Postavke radnog profila"</string>
    <string name="managed_profile_contact_search_title" msgid="6034734926815544221">"Pretraživanje kontakata"</string>
    <string name="managed_profile_contact_search_summary" msgid="5431253552272970512">"Dozvolite svojoj organizaciji da pretražuje kontakte kako bi identificirala pozivaoce i kontakte"</string>
    <string name="cross_profile_calendar_title" msgid="4414835261437899531">"Kalendar na više profila"</string>
    <string name="cross_profile_calendar_summary" msgid="8139424817135929870">"Prikaz poslovnih događaja u ličnom kalendaru"</string>
    <string name="cross_profile_calendar_restricted_summary" msgid="295371538704418613">"Vaša organizacija ne dozvoljava da lične aplikacije pristupaju poslovnom kalendaru"</string>
    <plurals name="hours" formatted="false" msgid="7020844602875333472">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> sat</item>
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> sata</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> sati</item>
    </plurals>
    <plurals name="minutes" formatted="false" msgid="4666832442068789413">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> minuta</item>
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> minute</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> minuta</item>
    </plurals>
    <plurals name="seconds" formatted="false" msgid="3876307354560025025">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> sekunda</item>
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> sekunde</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> sekundi</item>
    </plurals>
    <string name="automatic_storage_manager_settings" msgid="7819434542155181607">"Upravljanje prostorom za pohranu"</string>
    <string name="automatic_storage_manager_text" msgid="4562950476680600604">"Radi lakšeg oslobađanja prostora za pohranu, upravitelj pohranom s vašeg uređaja uklanja sigurnosne kopije fotografija i videozapisa."</string>
    <string name="automatic_storage_manager_days_title" msgid="2017913896160914647">"Ukloni fotografije i videozapise"</string>
    <string name="automatic_storage_manager_preference_title" msgid="5753702798151073383">"Upravitelj prostora za pohranu"</string>
    <string name="automatic_storage_manager_master_switch_title" msgid="6792996736190821417">"Koristi Upravitelja pohrane"</string>
    <string name="deletion_helper_automatic_title" msgid="6605660435498272520">"Automatski"</string>
    <string name="deletion_helper_manual_title" msgid="7947432164411214029">"Ručno"</string>
    <string name="deletion_helper_preference_title" msgid="5271510052022285884">"Oslobodite prostor odmah"</string>
    <string name="gesture_preference_title" msgid="5280023307132819052">"Pokreti"</string>
    <string name="gesture_preference_summary" product="default" msgid="8627850388011956901">"Brzi pokreti za kontrolu nad telefonom"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4717535378272065510">"Brzi pokreti za kontrolu nad tableta"</string>
    <string name="gesture_preference_summary" product="device" msgid="4205941452664950852">"Brzi pokreti za kontrolu uređaja"</string>
    <string name="double_tap_power_for_camera_title" msgid="64716226816032800">"Prelazak na kameru"</string>
    <string name="double_tap_power_for_camera_summary" msgid="242037150983277829">"Dodirnite dvaput dugme za uključivanje za brzo otvaranje kamere. Funkcionira na svakom ekranu."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="6500405261202883589">"Brzo otvorite kameru"</string>
    <string name="double_twist_for_camera_mode_title" msgid="4877834147983530479">"Obrtanje kamere"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="122977081337563340"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="4689410222517954869">"Snimajte selfije brže"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="5367798220225997418">"Za prelazak s jedne aplikacije na drugu, prevucite prema gore na dugmetu za Početni ekran za promjenu aplikacije. Ponovo prevucite prema gore da pogledate sve aplikacije. Funkcionira na svakom ekranu. Više nećete imati dugme za Pregled u donjem desnom dijelu ekrana."</string>
    <string name="swipe_up_to_switch_apps_suggestion_title" msgid="1465200107913259595">"Isprobajte novo dugme za Početni ekran"</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="4825314186907812743">"Uključite novi pokret za promjenu aplikacije"</string>
    <string name="ambient_display_title" product="default" msgid="5144814600610448504">"Provjera telefona dvostrukim dodirom"</string>
    <string name="ambient_display_title" product="tablet" msgid="8688795028609563837">"Provjera tableta dvostrukim dodirom"</string>
    <string name="ambient_display_title" product="device" msgid="3423781975742145894">"Provjera uređaja dvostrukim dodirom"</string>
    <string name="ambient_display_summary" msgid="8534654210539169707">"Dvaput dodirnite ekran da provjerite vrijeme, obavještenja i druge informacije."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="818688002837687268">"Provjera telefona kad se podigne"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="4455864282995698097">"Podignite za provjeru tableta"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="5380534405773531175">"Podignite za provjeru uređaja"</string>
    <string name="ambient_display_wake_screen_title" msgid="4091523525326925790">"Aktiviranje ekrana"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="3436302177038243869">"Podignite telefon da provjerite vrijeme, obavještenja i druge informacije."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="4938504160398665156">"Da provjerite vrijeme, obavještenja i druge informacije, podignite tablet."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="4264958533375250254">"Da provjerite vrijeme, obavještenja i druge informacije, podignite uređaj."</string>
    <string name="ambient_display_tap_screen_title" product="default" msgid="5458679563086979424">"Dodirnite da provjerite telefon"</string>
    <string name="ambient_display_tap_screen_title" product="tablet" msgid="9108878716863882877">"Dodirnite da provjerite tablet"</string>
    <string name="ambient_display_tap_screen_title" product="device" msgid="7071150656699666085">"Dodirnite da provjerite uređaj"</string>
    <string name="ambient_display_tap_screen_summary" msgid="8862155601920379979">"Da provjerite vrijeme, obavještenja i druge informacije, dodirnite ekran."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="5816346492253270243">"Prevlačenje prstom za obavještenja"</string>
    <string name="fingerprint_gesture_screen_title" msgid="8562169633234041196">"Prevlačenje prstom"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="1770661868393713922">"Da provjerite obavještenja, prevucite prstom prema dolje po senzoru za otisak prsta na poleđini uređaja."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet" msgid="902719947767712895">"Da provjerite obavještenja, prevucite prstom prema dolje po senzoru za otisak prsta na poleđini uređaja."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="device" msgid="5372926094116306647">"Da provjerite obavještenja, prevucite prstom prema dolje po senzoru za otisak prsta na poleđini uređaja."</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="1677291167470357802">"Brzo pregledajte obavještenja"</string>
    <string name="gesture_setting_on" msgid="3455094265233870280">"Uključeno"</string>
    <string name="gesture_setting_off" msgid="5230169535435881894">"Isključeno"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="4265541229765635629">"Program za učitavanje operativnog sistema je već otključan"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="3361344735430813695">"Prvo se povežite na internet"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="2479038689567925511">"Povežite se na internet ili kontaktirajte svog operatera"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="4149387448213399630">"Nedostupno na uređajima koje je zaključao operater"</string>
    <string name="oem_lock_info_message" msgid="9218313722236417510">"Ponovo pokrenite uređaj da omogućite funkciju zaštite uređaja."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="7517560170441007788">"<xliff:g id="SIZE">%1$s</xliff:g> je ukupno na raspolaganju\n\nPosljednji put je pokrenuto <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="4051513950976670853">"Instant aplikacije"</string>
    <string name="web_action_enable_summary" msgid="3108127559723396382">"Otvaranje linkova u aplikacijama, čak iako nisu instalirane"</string>
    <string name="web_action_section_title" msgid="7364647086538399136">"Instant aplikacije"</string>
    <string name="instant_apps_settings" msgid="8827777916518348213">"Postavke instant aplikacija"</string>
    <string name="domain_url_section_title" msgid="7046835219056428883">"Instalirane aplikacije"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="6353100011690933254">"Vašom pohranom sada upravlja upravitelj pohrane"</string>
    <string name="account_for_section_header" msgid="5356566418548737121">"Računi korisnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="configure_section_header" msgid="7391183586410814450">"Konfiguriraj"</string>
    <string name="auto_sync_account_title" msgid="898796354710116383">"Automatsko sinhroniziranje podataka"</string>
    <string name="auto_sync_personal_account_title" msgid="8496263182646100610">"Automatsko sinhroniziranje ličnih podataka"</string>
    <string name="auto_sync_work_account_title" msgid="4489172450037434152">"Automatsko sinhroniziranje radnih podataka"</string>
    <string name="auto_sync_account_summary" msgid="692499211629185107">"Omogućava aplikacijama automatsko osvježavanje podataka"</string>
    <string name="account_sync_title" msgid="7214747784136106491">"Sinhronizacija računa"</string>
    <string name="account_sync_summary_some_on" msgid="3375930757891381175">"Sinhronizacija uključena za stavke: <xliff:g id="ID_1">%1$d</xliff:g> od ukupno <xliff:g id="ID_2">%2$d</xliff:g>"</string>
    <string name="account_sync_summary_all_on" msgid="570431636622254156">"Sinhronizacija je uključena za sve stavke"</string>
    <string name="account_sync_summary_all_off" msgid="8782409931761182734">"Sinhronizacija je isključena za sve stavke"</string>
    <string name="enterprise_privacy_settings" msgid="1177106810374146496">"Podaci o upravljanom uređaju"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5853292305730761128">"Promjene i postavke kojima upravlja vaša organizacija"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="4266234968317996188">"Promjene i postavke kojima upravlja organizacija <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="7402406406883832509">"Za davanje pristupa vašim radnim podacima, vaša organizacija može na vašem uređaju promijeniti postavke i instalirati softver.\n\nZa više informacija, obratite se administratoru vaše organizacije."</string>
    <string name="enterprise_privacy_exposure_category" msgid="7313392680107938517">"Vrste informacija koje vaša organizacija može vidjeti"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="9079283547182933771">"Izmjene koje je izvršio adminstrator vaše organizacije"</string>
    <string name="enterprise_privacy_device_access_category" msgid="5423434164248819058">"Vaš pristup ovom uređaju"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="2773968662865848413">"Podaci koji su povezani s vašim računom, kao što su e-pošta ili kalendar"</string>
    <string name="enterprise_privacy_installed_packages" msgid="2313698828178764590">"Spisak aplikacija na vašem uređaju"</string>
    <string name="enterprise_privacy_usage_stats" msgid="4398411405572759370">"Utrošeno vrijeme i podaci za svaku aplikaciju"</string>
    <string name="enterprise_privacy_network_logs" msgid="161722817268849590">"Najskoriji zapis mrežnog saobraćaja"</string>
    <string name="enterprise_privacy_bug_reports" msgid="843225086779037863">"Najnoviji izvještaj o greškama"</string>
    <string name="enterprise_privacy_security_logs" msgid="5377362481617301074">"Najnoviji zapisnik o aktivnostima"</string>
    <string name="enterprise_privacy_none" msgid="7706621148858381189">"Nema"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="6353757812144878828">"Aplikacije su instalirane"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7433213592572082606">"Broj aplikacija je samo procjena. Možda nisu obuhvaćene aplikacije koje su instalirane izvan Play trgovine."</string>
    <plurals name="enterprise_privacy_number_packages_lower_bound" formatted="false" msgid="3005116533873542976">
      <item quantity="one">Najmanje <xliff:g id="COUNT_1">%d</xliff:g> aplikacija</item>
      <item quantity="few">Najmanje <xliff:g id="COUNT_1">%d</xliff:g> aplikacije</item>
      <item quantity="other">Najmanje <xliff:g id="COUNT_1">%d</xliff:g> aplikacija</item>
    </plurals>
    <string name="enterprise_privacy_location_access" msgid="4158197200885270634">"Odobrenja za lokacije"</string>
    <string name="enterprise_privacy_microphone_access" msgid="5717375623568864441">"Odobrenja za mikrofon"</string>
    <string name="enterprise_privacy_camera_access" msgid="4858146118537519375">"Odobrenja za kameru"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="3288495615791128724">"Zadane aplikacije"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="2765037387436064893">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> aplikacija</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> aplikacije</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aplikacija</item>
    </plurals>
    <string name="enterprise_privacy_input_method" msgid="6531350246850814920">"Zadana tastatura"</string>
    <string name="enterprise_privacy_input_method_name" msgid="4941106433683067953">"Postavljeno kao <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="4409098287763221215">"Uključen je uvijek aktivni VPN"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="9217774730260037434">"Uvijek aktivni VPN je uključen u vašem ličnom profilu"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="7244472958208315814">"Uvijek aktivni VPN je uključen u vašem radnom profilu"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="7936664553416257333">"Globalno postavljanje za HTTP proksi"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="2019652712782510262">"Pouzdani akreditivi"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="2279084820904076599">"Pouzdani akreditivi na vašem ličnom profilu"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="6187377647815301809">"Pouzdani akreditivi na vašem radnom profilu"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="526375234629534165">
      <item quantity="one">Najmanje <xliff:g id="COUNT_1">%d</xliff:g> CA certifikat</item>
      <item quantity="few">Najmanje <xliff:g id="COUNT_1">%d</xliff:g> CA certifikata</item>
      <item quantity="other">Najmanje <xliff:g id="COUNT_1">%d</xliff:g> CA certifikata</item>
    </plurals>
    <string name="enterprise_privacy_lock_device" msgid="8791656477097208540">"Administrator može zaključati uređaj i postaviti novu lozinku"</string>
    <string name="enterprise_privacy_wipe_device" msgid="2821960015797241790">"Administrator može izbrisati sve podatke iz uređaja"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="1001255609345002878">"Neuspjeli pokušaji upisivanja lozinke prije brisanja svih podataka na uređaju"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="4040565826652951057">"Neuspjeli pokušaji upisivanja lozinke prije brisanja svih podataka radnog profila"</string>
    <plurals name="enterprise_privacy_number_failed_password_wipe" formatted="false" msgid="5279099270351036696">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> pokušaj</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> pokušaja</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> pokušaja</item>
    </plurals>
    <string name="do_disclosure_generic" msgid="8653670456990823307">"Ovim uređajem upravlja vaša organizacija."</string>
    <string name="do_disclosure_with_name" msgid="1141081465968481380">"Ovim uređajem upravlja <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="3558079393757238670">" "</string>
    <string name="learn_more" msgid="2623878455042103404">"Saznajte više"</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="1134677050353971363">
      <item quantity="one">Aplikacija za kameru</item>
      <item quantity="few">Aplikacije za kameru</item>
      <item quantity="other">Aplikacija za kameru</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="3545972964391065220">"Aplikacija za kalendar"</string>
    <string name="default_contacts_app_title" msgid="3497370557378660098">"Aplikacija za kontakte"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="42826975161049245">
      <item quantity="one">Aplikacija klijenta za e-poštu</item>
      <item quantity="few">Aplikacije klijenta za e-poštu</item>
      <item quantity="other">Aplikacija klijenta za e-poštu</item>
    </plurals>
    <string name="default_map_app_title" msgid="7560143381633608567">"Aplikacija za mape"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="6714041230953195024">
      <item quantity="one">Aplikacija za telefon</item>
      <item quantity="few">Aplikacije za telefon</item>
      <item quantity="other">Aplikacija za telefon</item>
    </plurals>
    <string name="app_names_concatenation_template_2" msgid="4309216198909946380">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="8949045544491604376">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_photos_videos" msgid="319854636702241898">"Fotografije i videozapisi"</string>
    <string name="storage_music_audio" msgid="789779084825206838">"Muzika i zvuk"</string>
    <string name="storage_games" msgid="7703159201697117621">"Igre"</string>
    <string name="storage_other_apps" msgid="5524321740031718083">"Druge aplikacije"</string>
    <string name="storage_files" msgid="8581083146777364063">"Fajlovi"</string>
    <string name="storage_size_large_alternate" msgid="3395208658399637645">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">^2</xliff:g>"</font></small>""</string>
    <string name="storage_volume_total" msgid="3499221850532701342">"Iskorišteno od <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_percent_full" msgid="6095012055875077036">"iskor."</string>
    <string name="clear_instant_app_data" msgid="2004222610585890909">"Obriši aplikaciju"</string>
    <string name="clear_instant_app_confirmation" msgid="7451671214898856857">"Želite li ukloniti ovu instant aplikaciju?"</string>
    <string name="launch_instant_app" msgid="391581144859010499">"Otvori"</string>
    <string name="game_storage_settings" msgid="3410689937046696557">"Igre"</string>
    <string name="audio_files_title" msgid="4777048870657911307">"Audio fajlovi"</string>
    <string name="app_info_storage_title" msgid="5554719444625611987">"Iskorišteni prostor"</string>
    <string name="webview_uninstalled_for_user" msgid="1819903169194420983">"(deinstalirano za korisnika <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="1216426047631256825">"(onemogućeno za korisnika <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7338387238377914374">"Usluga automatskog popunjavanja"</string>
    <string name="autofill_keywords" msgid="7485591824120812710">"automatski, popunjavanje, automatsko popunjavanje"</string>
    <string name="autofill_confirmation_message" msgid="2784869528908005194">"&lt;b&gt;Vodite računa da je to pouzdana aplikacija&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google Automatsko popunjavanje&gt;%1$s&lt;/xliff:g&gt; koristi sadržaj na vašem ekranu da odredi šta se može automatski popuniti."</string>
    <string name="debug_autofill_category" msgid="8050326960545979035">"Automatsko popunjavanje"</string>
    <string name="autofill_logging_level_title" msgid="899483289251346778">"Nivo zapisivanja"</string>
    <string name="autofill_max_partitions" msgid="7590272120101271461">"Maksimalni broj zahtijeva po sesiji"</string>
    <string name="autofill_max_visible_datasets" msgid="4531033613378881109">"Maksimalan broj vidljivih kompleta podataka"</string>
    <string name="autofill_reset_developer_options" msgid="5819016237049525099">"Vraćanje na zadane vrijednosti"</string>
    <string name="autofill_reset_developer_options_complete" msgid="7548288932341619412">"Opcije za programere za automatsko popunjavanje su vraćene na zadane postavke"</string>
    <string name="device_theme" msgid="4571803018917608588">"Tema uređaja"</string>
    <string name="default_theme" msgid="7085644992078579076">"Zadano"</string>
    <string name="show_operator_name_title" msgid="805135053530442951">"Naziv mreže"</string>
    <string name="show_operator_name_summary" msgid="5962567590205757550">"Prikaz naziva mreže na statusnoj traci"</string>
    <string name="storage_manager_indicator" msgid="1516810749625915020">"Upravitelj pohranom: <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="7488057587180724388">"Isključeno"</string>
    <string name="storage_manager_indicator_on" msgid="8625551710194584733">"Uključeno"</string>
    <string name="install_type_instant" msgid="3174425974536078647">"Instant aplikacija"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="5605210730828410482">"Želite li isključiti upravitelja pohranom?"</string>
    <string name="storage_movies_tv" msgid="5498394447562086890">"Aplikacije za filmove i TV"</string>
    <string name="carrier_provisioning" msgid="4398683675591893169">"Operater koji pruža informacije"</string>
    <string name="trigger_carrier_provisioning" msgid="3434865918009286187">"Aktiviranje dodjele resursa operatera"</string>
    <string name="zen_suggestion_title" msgid="798067603460192693">"Ažurirajte način rada Ne ometaj"</string>
    <string name="zen_suggestion_summary" msgid="5928686804697233014">"Pauzirajte obavještenja da ostanete fokusirani"</string>
    <string name="disabled_low_ram_device" msgid="3751578499721173344">"Ova funkcija nije dostupna na ovom uređaju"</string>
    <string name="disabled_feature" msgid="2102058661071271076">"Ova funkcija nije dostupna"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="6377125503096655882">"Ona će usporiti ovaj telefon"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1294470289520660584">"Prisilno omogući potpuno GNSS mjerenje"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="496344699046454200">"Praćenje svih konstelacija i frekvencija GNSS-a bez ciklusa rada"</string>
    <string name="allow_background_activity_starts" msgid="4121456477541603005">"Dozvoli pokretanja aktivnosti u pozadini"</string>
    <string name="allow_background_activity_starts_summary" msgid="6837591829176921245">"Dozvoljava sva pokretanja aktivnosti u pozadini"</string>
    <string name="show_first_crash_dialog" msgid="8889957119867262599">"Uvijek prikaži dijaloški okvir za pad aplikacije"</string>
    <string name="show_first_crash_dialog_summary" msgid="703224456285060428">"Prikaz dijaloškog okvira pri svakom padu aplikacije"</string>
    <string name="angle_enabled_app" msgid="1841862539745838255">"Odaberite aplikaciju u kojoj je omogućen ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="864740024581634768">"Aplikacija u kojoj je omogućen ANGLE nije postavljena"</string>
    <string name="angle_enabled_app_set" msgid="226015765615525056">"Aplikacija u kojoj je omogućen ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="game_driver_dashboard_title" msgid="8804074441354504919">"Postavke drajvera za igru"</string>
    <string name="game_driver_dashboard_summary" msgid="2392113100578771289">"Promijenite postavke drajvera za igru"</string>
    <string name="game_driver_footer_text" msgid="3202576403048267763">"Kada je drajver za igru uključen možete odabrati da za aplikacije koje su instalirane na uređaju koristite ažurirani drajver za grafiku."</string>
    <string name="game_driver_all_apps_preference_title" msgid="6067527642706295180">"Omogućeno za sve aplikacije"</string>
    <string name="game_driver_app_preference_title" msgid="5072626013346650374">"Odabir drajvera za grafiku"</string>
    <string name="game_driver_app_preference_default" msgid="7686384740483216333">"Zadano"</string>
    <string name="game_driver_app_preference_game_driver" msgid="6426312331295324606">"Drajver za igru"</string>
    <string name="game_driver_app_preference_system" msgid="8272672982113332753">"Drajver za grafiku sistema"</string>
    <!-- no translation found for game_driver_app_preference_values:0 (4271044622117073985) -->
    <!-- no translation found for game_driver_app_preference_values:1 (6628516810440406199) -->
    <!-- no translation found for game_driver_app_preference_values:2 (1760397725970916076) -->
    <string name="unsupported_setting_summary" product="default" msgid="11246953620654225">"Postavka nije podržana na ovom telefonu"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="6328431665635673717">"Postavka nije podržana na ovom tabletu"</string>
    <string name="unsupported_setting_summary" product="device" msgid="2348970994972110886">"Postavka nije podržana na ovom uređaju"</string>
    <string name="disabled_for_user_setting_summary" msgid="3388525317680711262">"Trenutni korisnik ne može promijeniti postavku"</string>
    <string name="disabled_dependent_setting_summary" msgid="8291322239940946902">"Zavisi od druge postavke"</string>
    <string name="unknown_unavailability_setting_summary" msgid="4589584678033059435">"Postavka je nedostupna"</string>
    <string name="my_device_info_account_preference_title" msgid="342933638925781861">"Račun"</string>
    <string name="my_device_info_device_name_preference_title" msgid="7104085224684165324">"Naziv uređaja"</string>
    <string name="change_wifi_state_title" msgid="3261945855372885427">"Upravljanje WiFi mrežom"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="7942268646980694224">"family link da upravlja WiFi mrežom"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8434262633905502679">"Dozvolite ovoj aplikaciji da uključi ili isključi WiFi, skenira i konektuje se na WiFi, doda ili ukloni mreže, te pokrene lokalnu pristupnu tačku"</string>
    <string name="media_output_title" msgid="115223550977351699">"Reproduciranje medija"</string>
    <string name="media_output_default_summary" msgid="8115153381240348279">"Ovaj uređaj"</string>
    <string name="media_output_summary" product="default" msgid="6839458453831567167">"Telefon"</string>
    <string name="media_output_summary" product="tablet" msgid="7217221078578554515">"Tablet"</string>
    <string name="media_output_summary" product="device" msgid="5677420090811068649">"Uređaj"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="3533731701018680693">"Nedostupno za vrijeme poziva"</string>
    <string name="media_output_summary_unavailable" msgid="7970304720507697019">"Nedostupno"</string>
    <string name="take_call_on_title" msgid="6066362463436122655">"Primanje poziva"</string>
    <string name="cannot_change_apn_toast" msgid="4652498125702594916">"Ovaj APN se ne može promijeniti."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="752439050748267917">"Poboljšanje trajanja baterije tableta"</string>
    <string name="battery_suggestion_title" product="device" msgid="1507272328369733005">"Poboljšanje trajanja baterije uređaja"</string>
    <string name="battery_suggestion_title" product="default" msgid="4038053023336285165">"Poboljšanje trajanja baterije telefona"</string>
    <string name="battery_suggestion_summary" msgid="4585677159811722359"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="7840226017975251549">"Sprečavanje zvonjenja"</string>
    <string name="gesture_prevent_ringing_title" msgid="5961391929839748111">"Pritisnite dugme za napajanje i pojačavanje zajedno da postavite na:"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="5724512060316688779">"Prečica za sprečavanje zvonjenja"</string>
    <string name="prevent_ringing_option_vibrate" msgid="7286821846542822661">"Vibracija"</string>
    <string name="prevent_ringing_option_mute" msgid="7551545579059879853">"Isključen zvuk"</string>
    <string name="prevent_ringing_option_none" msgid="4656046650769569175">"Ne čini ništa"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="1157524435626890116">"Uključeno (vibracija)"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="4472465110708640980">"Uključeno (isključen zvuk)"</string>
    <string name="prevent_ringing_option_none_summary" msgid="5013718946609276137">"Isključeno"</string>
    <string name="pref_title_network_details" msgid="7186418845727358964">"Detalji o mreži"</string>
    <string name="about_phone_device_name_warning" msgid="8885670415541365348">"Naziv uređaja mogu vidjeti aplikacije na telefonu. Mogu ga vidjeti i druge osobe kada se povežete na Bluetooth uređaje ili postavite WiFi pristupnu tačku."</string>
    <string name="devices_title" msgid="7701726109334110391">"Uređaji"</string>
    <string name="homepage_all_settings" msgid="1245540304900512919">"Sve postavke"</string>
    <string name="homepage_personal_settings" msgid="1570415428680432319">"Prijedlozi"</string>
    <string name="choose_network_title" msgid="5702586742615861037">"Odaberite mrežu"</string>
    <string name="network_disconnected" msgid="2933191767567503504">"Veza je prekinuta"</string>
    <string name="network_connected" msgid="4943925032253989621">"Povezano"</string>
    <string name="network_connecting" msgid="76404590784733557">"Povezivanje…"</string>
    <string name="network_could_not_connect" msgid="1113813392274155369">"Povezivanje nije uspjelo"</string>
    <string name="empty_networks_list" msgid="2578752112731781190">"Nije pronađena nijedna mreža."</string>
    <string name="network_query_error" msgid="7487714485362598410">"Nisu pronađene mreže. Pokušajte ponovo."</string>
    <string name="forbidden_network" msgid="4626592887509826545">"(zabranjeno)"</string>
    <string name="no_sim_card" msgid="1360669528113557381">"Nema SIM kartice"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="3956515670308744433">"Preferirani način rada mreže: preferiraj WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="5225727680228194864">"Preferirani način rada mreže: samo GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="8956197584659205699">"Preferirani način rada mreže: samo WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="4290654515569144276">"Preferirani način rada mreže: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="854981096234906594">"Preferirani način rada mreže: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="2578065433446506616">"Preferirani način rada mreže: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6604102246309629962">"Preferirani način rada mreže: samo CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="7558385602277592784">"Preferirani način rada mreže: samo EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="1742638677806401815">"Preferirani način rada mreže: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="8528755811985330696">"Preferirani način rada mreže: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="6632007438739933645">"Preferirani način rada mreže: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="5464960267483576515">"Preferirani način rada mreže: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_global_summary" msgid="8552400100470153638">"Preferirani način rada mreže: globalno"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="8037915274486919940">"Preferirani način rada mreže: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="104110625441127919">"Preferirani način rada mreže: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2561159741461407053">"Preferirani način rada mreže: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="1111689194136766011">"Preferirani način rada mreže: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="4272515966019344433">"Preferirani način rada mreže: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3138210224248737600">"Preferirani način rada mreže: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="7575595856957063853">"Preferirani način rada mreže: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="1512046749970721629">"Preferirani način rada mreže: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="1038314909945393905">"Preferirani način rada mreže: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="3277980364222159279">"Preferirani način rada mreže: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1572937828071126891">"Preferirani način rada mreže: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8393145171649288912">"Preferirani način rada mreže: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="5544016990994809932">"Preferirani način rada mreže: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_lte" msgid="1287709529829131860">"LTE (preporučeno)"</string>
    <string name="network_4G" msgid="8611758013994499559">"4G (preporučeno)"</string>
    <string name="network_global" msgid="959947774831178632">"Globalno"</string>
    <string name="label_available" msgid="1731547832803057893">"Dostupne mreže"</string>
    <string name="load_networks_progress" msgid="7709402068413190831">"Pretraživanje…"</string>
    <string name="register_on_network" msgid="766516026652295941">"Registriranje na mrežu <xliff:g id="NETWORK">%s</xliff:g> je u toku…"</string>
    <string name="not_allowed" msgid="1667079919821581706">"Vaša SIM kartica ne dozvoljava povezivanje na ovu mrežu."</string>
    <string name="connect_later" msgid="978991102125216741">"Trenutno se nije moguće povezati na ovu mrežu. Pokušajte ponovo kasnije."</string>
    <string name="registration_done" msgid="4573820010512184521">"Registrirano na mrežu."</string>
    <string name="select_automatically" msgid="7318032984017853975">"Automatski odaberi mrežu"</string>
    <string name="carrier_settings_title" msgid="3503012527671299886">"Postavke operatera"</string>
    <string name="cdma_lte_data_service" msgid="8507044148856536098">"Postavi prijenos podataka"</string>
    <string name="mobile_data_settings_title" msgid="7674604042461065482">"Prijenos podataka na mobilnoj mreži"</string>
    <string name="mobile_data_settings_summary" msgid="2708261377199805404">"Pristup prijenosu podataka mobilnom mrežom"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="2914985502279794000">"Telefon će se automatski prebaciti na ovog operatera kada bude u dometu"</string>
    <string name="calls_preference" msgid="4628557570999372758">"Postavke za pozive"</string>
    <string name="sms_preference" msgid="3479810211828513772">"Postavke za SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="2127802836576375306">"Pitaj svaki put"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9148476748420654283">"Dodavanje mreže"</string>
    <plurals name="mobile_network_summary_count" formatted="false" msgid="4505694491027023039">
      <item quantity="one"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM</item>
      <item quantity="few"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM-a</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM-ova</item>
    </plurals>
    <string name="default_for_calls" msgid="6732520879241581841">"Zadano za pozive"</string>
    <string name="default_for_sms" msgid="294276190503132313">"Zadano za SMS-ove"</string>
    <string name="default_for_calls_and_sms" msgid="3862322027700754792">"Zadano za pozive i SMS-ove"</string>
    <string name="default_for_mobile_data" msgid="955987144209828344">"Zadano za prijenos mobilnih podataka"</string>
    <string name="mobile_data_active" msgid="5108294051762397700">"Prijenos mobilnih podataka je aktivan"</string>
    <string name="mobile_data_off" msgid="5831854766113105657">"Prijenos mobilnih podataka je isključen"</string>
    <string name="subscription_available" msgid="6502502298446954785">"Dostupno"</string>
    <string name="mobile_network_in_range" msgid="8212440637838603215">"U dometu"</string>
    <string name="mobile_network_not_in_range" msgid="5287596455212313284">"Nije u dometu"</string>
    <string name="mobile_network_list_add_more" msgid="4000806369124701679">"Dodaj još"</string>
    <string name="mobile_network_active_sim" msgid="2375956837678169169">"Aktivno/SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="291768076436646044">"Neaktivno/SIM"</string>
    <string name="mobile_network_active_esim" msgid="4914509039134228659">"Aktivno/preuzet SIM"</string>
    <string name="mobile_network_inactive_esim" msgid="7653631389686307842">"Neaktivno/preuzeti SIM-ovi"</string>
    <string name="mobile_network_sim_name" msgid="5081645961314356327">"Naziv SIM-a"</string>
    <string name="mobile_network_sim_name_rename" msgid="7626733408098403107">"Promijeni naziv"</string>
    <string name="mobile_network_use_sim_on" msgid="8035448244261570189">"Koristite SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="889073420068380943">"Isključeno"</string>
    <string name="mobile_network_esim_swap_confirm_title" msgid="6546784593612512953">"Prebaciti na operatera <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="mobile_network_esim_swap_confirm_body" msgid="1621021150667547211">"Aktivan može biti samo po jedan SIM.\n\nPrebacivanjem na operatera <xliff:g id="CARRIER1">%1$s</xliff:g> neće se otkazati usluga operatera <xliff:g id="CARRIER2">%2$s</xliff:g>."</string>
    <string name="mobile_network_esim_swap_confirm_ok" msgid="8025086398614992834">"Prebaci na operatera <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="896275511321635947">"Izbriši SIM"</string>
    <string name="mobile_network_erase_sim_dialog_title" msgid="8211945787729023193">"Izbrisati ovaj preuzeti SIM?"</string>
    <string name="mobile_network_erase_sim_dialog_body" msgid="3363079846287650684">"Brisanjem ovog SIM-a, s ovog uređaja će se ukloniti usluga operatera <xliff:g id="CARRIER_0">%1$s</xliff:g>.\n\nUsluga za operatera <xliff:g id="CARRIER_1">%2$s</xliff:g> neće se otkazati."</string>
    <string name="mobile_network_erase_sim_dialog_ok" msgid="5130805470041783437">"Izbriši"</string>
    <string name="mobile_network_erase_sim_dialog_progress" msgid="6541813899575453878">"Brisanje SIM-a…"</string>
    <string name="mobile_network_erase_sim_error_dialog_title" msgid="730767308428197756">"Nije moguće izbrisati SIM"</string>
    <string name="mobile_network_erase_sim_error_dialog_body" msgid="6835262809290075813">"Nije moguće izbrisati ovaj SIM zbog greške.\n\nPonovo pokrenite uređaj i pokušajte ponovo."</string>
    <string name="preferred_network_mode_title" msgid="6505630109389684100">"Vrsta preferirane mreže"</string>
    <string name="preferred_network_mode_summary" msgid="1216219115667163264">"Promijeni način rada mreže"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="849254040214447984">"Vrsta preferirane mreže"</string>
    <string name="carrier_settings_euicc" msgid="8658562169133242581">"Operater"</string>
    <string name="carrier_settings_version" msgid="3469507893844448432">"Verzija postavki"</string>
    <string name="call_category" msgid="8108654745239563833">"Pozivanje"</string>
    <string name="video_calling_settings_title" msgid="8153216918491498505">"Operater video pozivanja"</string>
    <string name="cdma_system_select_title" msgid="7210256688912895790">"Odabir sistema"</string>
    <string name="cdma_system_select_summary" msgid="3413863051181111941">"Promijeni način rada CDMA rominga"</string>
    <string name="cdma_system_select_dialogtitle" msgid="1198883288864916563">"Odabir sistema"</string>
    <string name="network_operator_category" msgid="8451238364605724918">"Mreža"</string>
    <string name="network_select_title" msgid="8394621216255081026">"Mreža"</string>
    <string name="cdma_subscription_title" msgid="1473189596933979467">"CDMA pretplata"</string>
    <string name="cdma_subscription_summary" msgid="7191590908367194209">"Promjena između RUIM/SIM i NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="9153005469617575361">"pretplata"</string>
    <string name="register_automatically" msgid="518185886971595020">"Automatska registracija…"</string>
    <string name="roaming_alert_title" msgid="7458177294163751484">"Dozvoliti roming podataka?"</string>
    <string name="roaming_check_price_warning" msgid="4979418631753681300">"Raspitajte se kod svog mobilnog operatera za cijene."</string>
    <string name="mobile_data_usage_title" msgid="7862429216994894656">"Prijenos podataka u aplikaciji"</string>
    <string name="mobile_network_mode_error" msgid="4784347953600013818">"Mrežni način <xliff:g id="NETWORKMODEID">%1$d</xliff:g> nije važeći. Zanemarite."</string>
    <string name="mobile_network_apn_title" msgid="7610812642954395440">"Nazivi pristupne tačke"</string>
    <string name="manual_mode_disallowed_summary" msgid="2085670341790561153">"Nedostupno kada ste povezani s operaterom <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="emergency_info_contextual_card_summary" msgid="7993926837251874514">"Medicinske informacije, kontakti za hitne slučajeve"</string>
    <string name="see_more" msgid="5953815986207345223">"Pogledajte više"</string>
    <string name="see_less" msgid="1250265310929558370">"Vidi manje"</string>
    <string name="network_connection_request_dialog_title" msgid="3502355504717957803">"Korištenje uređaja s aplikacijom <xliff:g id="APPNAME">%1$s</xliff:g>"</string>
    <string name="network_connection_timeout_dialog_message" msgid="3711556077945728716">"Nije pronađen nijedan uređaj Provjerite jesu li uređaji uključeni i dostupni za povezivanje."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="8924405960181020156">"Pokušaj ponovo"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="6953778550775646710">"Nešto se dogodilo. Ova aplikacija je otkazala zahtjev za odabir uređaja."</string>
    <string name="network_connection_connect_successful" msgid="5935510954474494928">"Uspješno povezivanje"</string>
    <string name="network_connection_request_dialog_showall" msgid="6938922880244567521">"Prikaži sve"</string>
    <plurals name="show_bluetooth_devices" formatted="false" msgid="1715020480026568408">
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> povezan uređaj</item>
      <item quantity="few"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> povezana uređaja</item>
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> povezanih uređaja</item>
    </plurals>
    <string name="no_bluetooth_devices" msgid="861861879657732058">"Nema Bluetooth uređaja"</string>
    <string name="bluetooth_left_name" msgid="2133431890020995442">"Lijevo"</string>
    <string name="bluetooth_right_name" msgid="525578831502355410">"Desni"</string>
    <string name="bluetooth_middle_name" msgid="3272836932362043957">"Srednji uređaj"</string>
    <string name="settings_panel_title" msgid="4688575606213055744">"Ploča s postavkama"</string>
    <string name="internet_connectivity_panel_title" msgid="721392242301676444">"Povezivanje na internet"</string>
    <string name="volume_connectivity_panel_title" msgid="9192664643867101356">"Jačina zvuka"</string>
    <string name="mobile_data_ap_mode_disabled" msgid="1127588179830051811">"Nije dostupno dok je aktiviran način rada u avionu"</string>
    <string name="force_desktop_mode" msgid="4303240595324847998">"Nametni način rada na računaru"</string>
    <string name="force_desktop_mode_summary" msgid="6259798246015387202">"Nametanje eksperimentalnog načina rada na računaru na sekundarnim ekranima"</string>
    <string name="hwui_force_dark_title" msgid="2466919877609396257">"Nadjačaj nametanje tamne teme"</string>
    <string name="hwui_force_dark_summary" msgid="8705328793382981780">"Nadjačava funkciju nametanja tamne teme tako da je uvijek uključena"</string>
    <string name="privacy_dashboard_title" msgid="2458407399263943923">"Privatnost"</string>
    <string name="privacy_dashboard_summary" msgid="4570241983077984329">"Odobrenja, aktivnost računa, lični podaci"</string>
    <string name="contextual_card_dismiss_remove" msgid="2813670241047194713">"Ukloni"</string>
    <string name="contextual_card_dismiss_keep" msgid="2230740610451447340">"Zadrži"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="5507487987591500742">"Ukloniti ovaj prijedlog?"</string>
    <string name="contextual_card_removed_message" msgid="6744732110721136227">"Prijedlog je uklonjen"</string>
    <string name="contextual_card_undo_dismissal_text" msgid="3564089284222177020">"Poništi"</string>
    <string name="low_storage_summary" msgid="2077564126033530">"Ponestaje prostora za pohranu. Iskorišteno: <xliff:g id="PERCENTAGE">%1$s</xliff:g> – Slobodno: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="contextual_card_feedback_send" msgid="2996691837358030021">"Pošalji povratne informacije"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="8115454795160804779">"Želite li nam pružiti povratne informacije o ovom prijedlogu?"</string>
    <string name="copyable_slice_toast" msgid="2924110841440836023">"Sljedeći sadržaj je kopiran u međumemoriju: <xliff:g id="COPY_CONTENT">%1$s</xliff:g>"</string>
    <string name="search_bar_account_avatar_content_description" msgid="4718261366290530792"></string>
    <string name="permission_bar_chart_empty_text" msgid="4380731551728553852">"Nijedna aplikacija nije koristila odobrenja"</string>
    <string name="permission_bar_chart_title" msgid="2745425703472199837">"Korištenje odobrenja u posljednja 24 sata"</string>
    <string name="permission_bar_chart_details" msgid="2977943114535855210">"Prikaži sve na kontrolnoj tabli"</string>
    <plurals name="permission_bar_chart_label" formatted="false" msgid="5346938677887948252">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> aplikacija</item>
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> aplikacije</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> aplikacija</item>
    </plurals>
    <string name="accessibility_usage_title" msgid="5136753034714150614">"Korištenje pristupačnosti"</string>
    <plurals name="accessibility_usage_summary" formatted="false" msgid="5790789101231115740">
      <item quantity="one"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikacija ima potpuni pristup vašem uređaju</item>
      <item quantity="few"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikacije imaju potpuni pristup vašem uređaju</item>
      <item quantity="other"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> aplikacija ima potpuni pristup vašem uređaju</item>
    </plurals>
    <string name="manage_app_notification" msgid="4575452737886198216">"Upravljajte obavještenjima aplikacije <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="no_suggested_app" msgid="5722034393216359231">"Nema predloženih aplikacija"</string>
    <plurals name="notification_few_channel_count_summary" formatted="false" msgid="1090888820158822106">
      <item quantity="one"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_1">%1$d</xliff:g> kanal za obavještenja</item>
      <item quantity="few"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_1">%1$d</xliff:g> kanala za obavještenja</item>
      <item quantity="other"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_1">%1$d</xliff:g> kanala za obavještenja</item>
    </plurals>
    <string name="notification_many_channel_count_summary" msgid="8647409434789898073">"Broj kanala obavještenja: <xliff:g id="NOTIFICATION_CHANNEL_COUNT">%1$d</xliff:g>. Dodirnite da upravljate svim."</string>
    <string name="recently_installed_app" msgid="2877671740090335492">"Nedavno ste instalirali ovu aplikaciju."</string>
    <string name="media_output_panel_title" msgid="6197092814295528184">"Prebacite izlaz"</string>
    <string name="media_output_panel_summary_of_playing_device" msgid="629529380940058789">"Trenutno se reproducira na uređaju <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wfc_disclaimer_title_text" msgid="6164569741719679613">"Važne informacije"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="1405773141236165542">"NASTAVI"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="2700358281438736674">"NE, HVALA"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="6658735446562619865">"Lokacija"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="3096546236221656018">"Vaš pružalac usluga može prikupljati podatke o vašoj lokaciji u cilju pružanja ove usluge.\n\nPregledajte pravila privatnosti svog pružaoca usluga."</string>
    <string name="forget_passpoint_dialog_message" msgid="7331876195857622224">"Možete izgubiti pristup preostalom vremenu ili podacima. Prije uklanjanja, provjerite s pružaocem usluga."</string>
    <string name="keywords_content_capture" msgid="859132453327059493">"snimanje sadržaja"</string>
    <string name="content_capture" msgid="6456873729933463600">"Snimanje sadržaja"</string>
    <string name="content_capture_summary" msgid="659506647507221852">"Dopusti aplikacijama da šalju sadržaj Android sistemu"</string>
    <string name="capture_system_heap_dump_title" msgid="8043655498113164693">"Snimi snimak dinamičkog dijela memorije sistema"</string>
    <string name="capturing_system_heap_dump_message" msgid="8680086369500395131">"Snimanje dinamičkog dijela memorije sistema"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="6346229989760615103">"Snimak dinamičkog dijela memorije sistema nije snimljen."</string>
    <string name="automatic_system_heap_dump_title" msgid="442496436397957988">"Automatsko snimanje snimaka dinamičkog dijela memorije sistema"</string>
    <string name="automatic_system_heap_dump_summary" msgid="8253838659009241350">"Automatski snimi snimke dinamičkog dijela memorije za Android sistem kada koristi previše memorije"</string>
    <string name="wifi_disconnect_button_text" msgid="2032651902928903819">"Prekini vezu"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="3354031536141983602">"Hitni pozivi"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="6068582272230311464">"Vaš operater ne podržava hitne pozive preko funkcije Pozivanje putem WiFi-ja.\nUređaj će se automatski prebaciti na mobilnu mrežu kako bi se uspostavio hitni poziv.\nHitni pozivi su mogući samo na područjima pokrivenim mobilnom mrežom."</string>
</resources>
