<?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">"Izradi"</string>
    <string name="allow" msgid="3349662621170855910">"Dopusti"</string>
    <string name="deny" msgid="6947806159746484865">"Odbij"</string>
    <string name="dlg_close" msgid="7471087791340790015">"Zatvori"</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 i postat ćete razvojni programer.</item>
      <item quantity="few">Još <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> koraka i postat ćete razvojni programer.</item>
      <item quantity="other">Još <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> koraka i postat ćete razvojni programer.</item>
    </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Sad ste razvojni programer!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Nema potrebe, već ste razvojni programer."</string>
    <string name="dev_settings_disabled_warning" msgid="4909448907673974370">"Najprije omogućite opcije za razvojne programere."</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Bežično povezivanje i mreže"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Sustav"</string>
    <string name="radio_info_data_connection_enable" msgid="8656750679353982712">"Omogući podatkovnu vezu"</string>
    <string name="radio_info_data_connection_disable" msgid="8541302390883231216">"Onemogući podatkovnu vezu"</string>
    <string name="volte_provisioned_switch_string" msgid="7979882929810283786">"VoLTE omogućen"</string>
    <string name="vt_provisioned_switch_string" msgid="7876998291744854759">"Pružena usluga videopoziva"</string>
    <string name="wfc_provisioned_switch_string" msgid="3985406545172898078">"Pružena usluga poziva putem Wi-Fi-ja"</string>
    <string name="eab_provisioned_switch_string" msgid="3482272907448592975">"Pruža se usluga EAB-a/prisutnosti"</string>
    <string name="radio_info_radio_power" msgid="7187666084867419643">"Snaga mobilnog radija"</string>
    <string name="radioInfo_menu_viewADN" msgid="7069468158519465139">"Prikaži imenik SIM-a"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Prikaži brojeve za fiksno biranje"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Prikaži brojeve za servisno biranje"</string>
    <string name="radioInfo_menu_getIMS" msgid="185171476413967831">"Status usluge IMS-a"</string>
    <string name="radio_info_ims_reg_status_title" msgid="16971785902696970">"Status IMS-a"</string>
    <string name="radio_info_ims_reg_status_registered" msgid="5614116179751126247">"Registriran"</string>
    <string name="radio_info_ims_reg_status_not_registered" msgid="4438054067642750717">"Nije registriran"</string>
    <string name="radio_info_ims_feature_status_available" msgid="3687807290327566879">"Dostupan"</string>
    <string name="radio_info_ims_feature_status_unavailable" msgid="4606182208970114368">"Nedostupan"</string>
    <string name="radio_info_ims_reg_status" msgid="7534612158445529715">"Registracija IMS-a: <xliff:g id="STATUS">%1$s</xliff:g>\nVoice over LTE: <xliff:g id="AVAILABILITY_0">%2$s</xliff:g>\nVoice over WiFi: <xliff:g id="AVAILABILITY_1">%3$s</xliff:g>\nVideopozivi: <xliff:g id="AVAILABILITY_2">%4$s</xliff:g>\nUT sučelje: <xliff:g id="AVAILABILITY_3">%5$s</xliff:g>"</string>
    <string name="radioInfo_service_in" msgid="1697703164394784618">"Upotrebljava se"</string>
    <string name="radioInfo_service_out" msgid="7999094221728929681">"Ne radi"</string>
    <string name="radioInfo_service_emergency" msgid="6274434235469661525">"Samo hitni pozivi"</string>
    <string name="radioInfo_service_off" msgid="7536423790014501173">"Radio je isključen"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="4849214885629672819">"Bez roaminga"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"U mirovanju"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Zvono"</string>
    <string name="radioInfo_phone_offhook" msgid="5873835692449118954">"Razgovor u tijeku"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Niste povezani"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Povezivanje"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Povezan"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Obustavljeno"</string>
    <string name="radioInfo_unknown" msgid="1476509178755955088">"Nepoznato"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"pkts"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"bajtovi"</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">"Isključi USB memoriju"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Isključi SD karticu"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Izbriši memoriju USB"</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, stranica <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 zaslonu."</string>
    <string name="font_size_make_smaller_desc" msgid="7919995133365371569">"Smanji"</string>
    <string name="font_size_make_larger_desc" msgid="4316986572233686061">"Povećaj"</string>
    <!-- no translation found for font_size_preview_text (4818424565068376732) -->
    <skip />
    <string name="font_size_preview_text_headline" msgid="7955317408475392247">"Primjer teksta"</string>
    <string name="font_size_preview_text_title" msgid="1310536233106975546">"Čarobnjak iz Oza"</string>
    <string name="font_size_preview_text_subtitle" msgid="4231671528173110093">"11. poglavlje: Čudesni Smaragdni Grad čarobnjaka Oza"</string>
    <string name="font_size_preview_text_body" msgid="2846183528684496723">"Čak i sa zelenim naočalama koje su im štitile oči Dorothy i njezini prijatelji isprva su bili zaslijepljeni sjajem prekrasnoga Grada. Ulicama su se nizale predivne kuće sve izgrađene od zelenog mramora i cijele optočene svjetlucavim smaragdima. Hodali su pločnikom od istog zelenog mramora, a na mjestima gdje su se kameni blokovi spajali nalazili su se redovi gusto postavljenih smaragda koji su svjetlucali na jarkom suncu. Prozori su bili od zelenog stakla, a čak je i nebo iznad Grada imalo zeleni odsjaj i sunčeve su zrake bile zelene boje. \n\nNa ulicama je bilo mnogo ljudi, muškaraca, žena i djece, i svi su bili odjeveni u zeleno i imali zelenkastu put. S čuđenjem su gledali Dorothy i njezinu neobičnu, šaroliku pratnju i sva su se djeca sakrila iza svojih majki kada su ugledala Lava, no nitko im se nije obratio. Mnoge su trgovine bile otvorene na ulicu i Dorothy je mogla vidjeti kako je u njima sve zeleno. Prodavali su se zeleni slatkiši i zelene kokice, kao i zelene cipele, zeleni šeširi i zelena odjeća svakojake vrste. Na jednom je mjestu jedan čovjek prodavao zelenu limunadu, a kad ju je koje dijete kupilo, Dorothy je mogla vidjeti kako je plaća zelenim novčićima. \n\nČinilo se da nije bilo konja niti koje druge životinje, a ljudi su naokolo vozili stvari u malim zelenim kolicima koja su gurali ispred sebe. Svi su se činili sretnima, zadovoljnima i uspješnima."</string>
    <string name="font_size_save" msgid="3450855718056759095">"U redu"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Memorija USB"</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">"Vidljivo svim Bluetooth uređajima u blizini (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Vidljivo svim Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Nije vidljiv drugim Bluetooth uređajima"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Vidljivo samo uparenim uređajima"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Vidljivost je istekla"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Zaključaj biranje glasom"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Spriječite upotrebu Bluetooth birača ako je zaslon 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">"Bez postavke imena, koristi naziv računa"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Skeniranjem traži uređaje"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Preimenuj ovaj uređaj"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Preimenuj"</string>
    <string name="bluetooth_disconnect_title" msgid="7830252930348734303">"Prekinuti vezu uređaja?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="8208712728668714199">"Vaš će telefon 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š će tablet 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š će uređaj prekinuti vezu s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="3308586619539119106">"Prekini"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="603521233563983689">"Nemate dopuštenje za promjenu postavki Bluetootha."</string>
    <string name="bluetooth_pairing_pref_title" msgid="7429413067477968637">"Upari novi uređaj"</string>
    <string name="bluetooth_is_visible_message" msgid="6222396240776971862">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> vidljiv je 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 s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Emitiranje"</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">"U blizini nema Bluetooth uređaja."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Zahtjev za uparivanje Bluetoothom"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Zahtjev za uparivanje"</string>
    <string name="bluetooth_notif_message" msgid="5057417127600942904">"Dodirnite za uparivanje s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="3144149432555230410">"Primljene datoteke"</string>
    <string name="bluetooth_show_files_received_via_bluetooth" msgid="5445105773989432594">"Datoteke primljene Bluetoothom"</string>
    <string name="device_picker" msgid="4978696506172252813">"Odaberite 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 isključ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 uključiti Bluetooth"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="4791779658660357386">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi vaš tablet učiniti vidljivim drugim Bluetooth uređajima na <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 vaš telefon učiniti vidljivim drugim Bluetooth uređajima na <xliff:g id="TIMEOUT">%2$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery_no_name" product="tablet" msgid="225715443477752935">"Aplikacija želi vaš tablet učiniti vidljivim drugim Bluetooth uređajima na <xliff:g id="TIMEOUT">%1$d</xliff:g> s."</string>
    <string name="bluetooth_ask_discovery_no_name" product="default" msgid="4949152735544109994">"Aplikacija želi vaš telefon učiniti vidljivim drugim Bluetooth uređajima na <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 učiniti vaš tablet vidljivim drugim Bluetooth uređajima. To možete kasnije promijeniti u postavkama Bluetootha."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="4398738575307583138">"<xliff:g id="APP_NAME">%1$s</xliff:g> želi učiniti vaš telefon vidljivim drugim Bluetooth uređajima. To možete kasnije promijeniti u postavkama Bluetootha."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet" msgid="1702590641426207062">"Aplikacija želi učiniti vaš tablet vidljivim drugim Bluetooth uređajima. To možete kasnije promijeniti u postavkama Bluetootha."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="default" msgid="8549952177383992238">"Aplikacija želi učiniti vaš telefon vidljivim drugim Bluetooth uređajima. To možete kasnije promijeniti u postavkama Bluetootha."</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 i vaš tablet učiniti vidljivim drugim uređajima na <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 i vaš telefon učiniti vidljivim drugim uređajima na <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 i vaš tablet učiniti vidljivim drugim uređajima na <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 i vaš telefon učiniti vidljivim drugim uređajima na <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 vaš tablet učiniti vidljivim drugim uređajima. To možete kasnije promijeniti u postavkama Bluetootha."</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 vaš telefon učiniti vidljivim drugim uređajima. To možete kasnije promijeniti u postavkama Bluetootha."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="tablet" msgid="692477613671555006">"Aplikacija želi uključiti Bluetooth i vaš tablet učiniti vidljivim drugim uređajima. To možete kasnije promijeniti u postavkama Bluetootha."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="default" msgid="6374480121751597648">"Aplikacija želi uključiti Bluetooth i vaš telefon učiniti vidljivim drugim uređajima. To možete kasnije promijeniti u postavkama Bluetootha."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Uključivanje Bluetootha…"</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Isključivanje Bluetootha?"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Zatražena je Bluetooth veza"</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">"Želite li se povezati s uređajem \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Zahtjev za pristup telefonskom imeniku"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="8930347091018455505">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi pristupiti vašim kontaktima i povijesti poziva. Želite li da <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> dobije pristup?"</string>
    <string name="bluetooth_remember_choice" msgid="6919682671787049800">"Više me ne pitaj"</string>
    <string name="bluetooth_pb_remember_choice" msgid="3622898084442402071">"Više me ne pitaj"</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 vašim porukama. Želite li dati pristup korisniku %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 SIM kartici. Dopuštanjem pristupa SIM kartici onemogućit će se podatkovna veza na uređaju za vrijeme povezanosti. Dopustite pristup uređaju <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g>"</string>
    <string name="bluetooth_device_name_summary" msgid="522235742194965734">"Drugim uređajima vidljiv kao \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\""</string>
    <string name="bluetooth_off_footer" msgid="8406865700572772936">"Uključite Bluetooth da biste se povezali 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">"Dopustite tabletu da komunicira s Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2205100629387332862">"Dopustite uređaju da komunicira s Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="782032074675157079">"Dopustite telefonu da komunicira s Bluetooth uređajima u blizini"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="4936610906348223810">"Onemogući Bluetooth A2DP hardversko rasterećenje"</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">"Ponovo pokrenite uređaj da biste promijenili tu postavku."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="2053793518537051975">"Pokreni"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="2382443064737856652">"Odustani"</string>
    <string name="connected_device_available_media_title" msgid="2560067541413280645">"Dostupni medijski uređaji"</string>
    <string name="connected_device_available_call_title" msgid="697154660967595684">"Dostupni uređaji za pozive"</string>
    <string name="connected_device_connected_title" msgid="5871712271201945606">"Trenutačno povezano"</string>
    <string name="connected_device_saved_title" msgid="688364359746674536">"Spremljeni uređaji"</string>
    <string name="connected_device_add_device_summary" msgid="4041865900298680338">"Bluetooth će se uključiti radi uparivanja"</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 povezano"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="5683648191381637533">"Bluetooth je uključen"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Datum i vrijeme"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Odabir vremenske zone"</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">"Očisti"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Priključak proxy poslužitelja"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Zaobiđi proxy za"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Vrati zadano"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Gotovo"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Naziv hosta proxy poslužitelja"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Pažnja"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"U redu"</string>
    <string name="proxy_error_invalid_host" msgid="6865850167802455230">"Naziv hosta koji ste upisali nije valjan."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="678527645450894773">"Popis za isključivanje koji ste napisali nije pravilno formatiran. Unesite popis isključenih domena odvojenih zarezima."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Morate dovršiti polje priključka."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Polje priključka mora biti prazno ako je i polje hosta prazno."</string>
    <string name="proxy_error_invalid_port" msgid="5988270202074492710">"Upisani priključak nije valjan."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Preglednik upotrebljava HTTP proxy poslužitelj, ali druge aplikacije ne mogu ga upotrebljavati."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"URL za PAC: "</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 (obustavljeno):"</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">"Stopa osvježavanja informacija u ćeliji:"</string>
    <string name="radio_info_cellinfo_label" msgid="6213223844927623098">"Sve informacije ćelija o mjerenju:"</string>
    <string name="radio_info_gprs_service_label" msgid="4209624131644060517">"Podatkovna usluga:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Roaming:"</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 PPP poništavanja od pokretanja:"</string>
    <string name="radio_info_current_network_label" msgid="9151285540639134945">"Trenutačna mreža:"</string>
    <string name="radio_info_ppp_received_label" msgid="363579470428151850">"Primljeni podaci:"</string>
    <string name="radio_info_gsm_service_label" msgid="1370863866816125489">"Glasovna 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">"Podaci poslani:"</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 radijsku frekvenciju"</string>
    <string name="radio_info_voice_network_type_label" msgid="1443496502370667071">"Vrsta glasovne mreže:"</string>
    <string name="radio_info_data_network_type_label" msgid="7094323145105149312">"Vrsta podatkovne mreže:"</string>
    <string name="radio_info_set_perferred_label" msgid="3511830813500105512">"Postavite željenu vrstu mreže:"</string>
    <string name="radio_info_ping_hostname_v4" msgid="7045103377818314709">"Pinganje naziva hosta (www.google.com) IPv4:"</string>
    <string name="radio_info_ping_hostname_v6" msgid="1130906124160553954">"Pinganje naziva hosta (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">"Uključi/isključi provjeru DNS-a"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Informacije/postavke koje se posebno odnose na OEM"</string>
    <string name="band_mode_title" msgid="4071411679019296568">"Postavi način radijske frekvencije"</string>
    <string name="band_mode_loading" msgid="3555063585133586152">"Učitavanje popisa frekvencija…"</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">"Promijene stupaju na snagu kod ponovnog priključivanja USB kabela."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Omogući USB masovno pohranjivanje"</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 memorija nije uključena."</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">"Dostupni bajtovi"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"USB pohrana upotrebljava se kao uređaj masovne pohrane."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"SD kartica upotrebljava se kao uređaj za masovnu pohranu."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="5128923500235719226">"Sad na siguran način možete ukloniti USB pohranu."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="666233604712540408">"Sad na siguran način možete ukloniti SD karticu."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"USB memorija uklonjena je dok se upotrebljavala!"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"SD kartica je uklonjena tijekom upotrebe!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Iskorišteni bajtovi:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Skeniranje USB mem. za medije…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Pretraživanje medija na SD kartici skeniranjem…"</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"USB memorija uključena samo za čitanje."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"SD kartica uključena je u načinu samo za čitanje."</string>
    <string name="skip_label" msgid="47510779345218297">"Preskoči"</string>
    <string name="next_label" msgid="4693520878012668114">"Dalje"</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">"Dodaj jezik"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="4276642359346122396">
      <item quantity="one">Želite li ukloniti odabrane jezike?</item>
      <item quantity="few">Želite li ukloniti odabrane jezike?</item>
      <item quantity="other">Želite li ukloniti odabrane jezike?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="1361354927342876114">"Tekst će se prikazivati na nekom drugom jeziku."</string>
    <string name="dlg_remove_locales_error_title" msgid="2653242337224911425">"Ne možete ukloniti sve jezike"</string>
    <string name="dlg_remove_locales_error_message" msgid="6697381512654262821">"Zadržite barem 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">"Premještanje gore"</string>
    <string name="action_drag_label_move_down" msgid="7448713844582912157">"Premještanje dolje"</string>
    <string name="action_drag_label_move_top" msgid="557081389352288310">"Premještanje na vrh"</string>
    <string name="action_drag_label_move_bottom" msgid="2468642142414126482">"Premještanje na dno"</string>
    <string name="action_drag_label_remove" msgid="2861038147166966206">"Uklanjanje jezika"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Odabir aktivnosti"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Informacije o uređaju"</string>
    <string name="display_label" msgid="8074070940506840792">"Zaslon"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Informacije o tabletnom uređaju"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informacije o telefonu"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Memorija USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"SD kartica"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Proxy postavke"</string>
    <string name="cancel" msgid="6859253417269739139">"Odustani"</string>
    <string name="okay" msgid="1997666393121016642">"U redu"</string>
    <string name="forget" msgid="1400428660472591263">"Zaboravi"</string>
    <string name="save" msgid="879993180139353333">"Spremi"</string>
    <string name="done" msgid="6942539184162713160">"Gotovo"</string>
    <string name="apply" msgid="1577045208487259229">"Primijeni"</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čac postavki"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Način rada u zrakoplovu"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Bežično povezivanje 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">"Mobilni podaci"</string>
    <string name="calls_title" msgid="3544471959217176768">"Pozivi"</string>
    <string name="sms_messages_title" msgid="1778636286080572535">"SMS poruke"</string>
    <string name="cellular_data_summary" msgid="4660351864416939504">"Dopusti prijenos pod. putem mobilne mreže"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Podatkovni promet u roamingu"</string>
    <string name="roaming" msgid="3596055926335478572">"Roaming podataka"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Povezivanje s podatkovnim uslugama u roamingu"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Povezivanje s podatkovnim uslugama u roamingu"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Izgubili ste podatkovnu vezu jer ste isključili mrežni roaming podataka."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Uključi"</string>
    <string name="roaming_warning" msgid="4275443317524544705">"To može biti dosta skupo."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Kada dopustite podatkovni roaming, mogu nastati značajni troškovi roaminga!\n\nOva postavka utječe na sve korisnike na ovom tabletu."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Kada dopustite podatkovni roaming, mogu nastati značajni troškovi roaminga!\n\nOva postavka utječe na sve korisnike na ovom telefonu."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Dopusti roaming podataka?"</string>
    <string name="networks" msgid="6333316876545927039">"Odabir operatora"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Odaberite mrežnog 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">"Postavite datum i vrijeme"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Postavljanje datuma, vremena, vremenske zone i formata"</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Automatski datum i vrijeme"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Upotrijebi vrijeme mreže"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Upotrijebi vrijeme mreže"</string>
    <string name="zone_auto" msgid="334783869352026648">"Automatska vremenska zona"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Upotrijebi vremensku zonu mreže"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Upotrijebi vremensku zonu mreže"</string>
    <string name="date_time_24hour_auto" msgid="2117383168985653422">"Automatski 24‑satni format"</string>
    <string name="date_time_24hour_auto_summary" msgid="6351812925651480277">"Upotrijebi lokalnu zadanu postavku"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"24-satni oblik"</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="date_time_set_time" msgid="5716856602742530696">"Postavi vrijeme"</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_set_date" msgid="7021491668550232105">"Postavi datum"</string>
    <string name="date_time_search_region" msgid="2478334699004021972">"Regija pretraživanja"</string>
    <string name="date_time_select_region" msgid="5434001881313168586">"Regija"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="6084375085203448645">"Odabir razlike u odnosu na UTC"</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">"Upotrebljava <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">"Upotrebljava <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Nema ljetnog vremena."</string>
    <string name="zone_time_type_dst" msgid="8850494578766845276">"Ljetno računanje vremena"</string>
    <string name="zone_time_type_standard" msgid="3462424485380376522">"Standardno računanje vremena"</string>
    <string name="zone_menu_by_region" msgid="8370437123807764346">"Odaberite po regiji"</string>
    <string name="zone_menu_by_offset" msgid="7161573994228041794">"Odaberite u odnosu na UTC"</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 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 kad ga <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> drži oključanim"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Prikaži vlasniku informacije o zaključanom zaslonu"</string>
    <string name="owner_info_settings_title" msgid="5530285568897386122">"Poruka na zaklj. zaslonu"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Omogući widgete"</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">"Prikazuje opciju tipke za uključivanje/isključivanje koja isključuje Smart Lock, otključavanje otiskom prsta i obavijesti na zaključanom zaslonu"</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">"Na primjer, Markov Android."</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Podaci o korisniku"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Prikaži informacije profila na zaključanom zaslonu"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Informacije profila"</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">"Upotreba lokacije"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Računi"</string>
    <string name="security_settings_title" msgid="4918904614964215087">"Sigurnost i lokacija"</string>
    <string name="encryption_and_credential_settings_title" msgid="6514904533438791561">"Enkripcija i vjerodajnice"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="8721883002237981248">"Telefon je kriptiran"</string>
    <string name="decryption_settings_summary" product="default" msgid="5671817824042639849">"Telefon nije kriptiran"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="7200428573872395685">"Uređaj je kriptiran"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="5794135636155570977">"Uređaj nije kriptiran"</string>
    <string name="lockscreen_settings_title" msgid="1099738951060387656">"Prikaz zaključanog zaslona"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="278055252361575926">"Što prikazati"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Postavi Moju lokaciju, otključavanje zaslona, zaključavanje SIM kartice, zaključavanje spremnika za vjerodajnice"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Postavi Moju lokaciju, otključavanje zaslona, zaključavanje pohranjivanja vjerodajnica"</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 zaslona, otključavanje licem"</string>
    <string name="security_dashboard_summary" msgid="6757421634477554939">"Zaključavanje zaslona, otisak prsta"</string>
    <string name="security_dashboard_summary_no_fingerprint" msgid="8129641548372335540">"Zaključavanje zaslona"</string>
    <string name="security_settings_face_preference_summary" msgid="1290187225482642821">"Lice dodano"</string>
    <string name="security_settings_face_preference_summary_none" msgid="5460349732790152186">"Dodirnite za postavljanje autent. licem"</string>
    <string name="security_settings_face_preference_title" msgid="7074548721778680481">"Autentifikacija licem"</string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="4277182322482408514">"Odustani"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="2694505011712885439">"Otključavanje licem"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="8180330567034286589">"Autentificirajte se licem"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="6150611993438981458">"Licem možete otključati telefon, autorizirati kupnje ili se prijaviti na aplikacije."</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="6393270235632444857">"Otključajte telefon ili odobrite kupnje svojim licem.\n\nNapomena: ovaj uređaj ne možete otključati licem. Za više informacija obratite se administratoru organizacije."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="5704661081718707858">"Licem možete otključati telefon, autorizirati kupnje ili se prijaviti na aplikacije"</string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4019853239039918762">"Postavite lice u središte kruga"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="1933553314312349529">"Učinit ću to kasnije"</string>
    <string name="face_add_max" msgid="4408683751143942949">"Ne možete dodati više od <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">"U redu"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="1701191960569185087">"Isteklo je vremensko ograničenje za registraciju lica. Pokušajte ponovo."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3825066262969499407">"Registracija lica nije uspjela."</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="8444494667872034497">"Pomoću lica možete"</string>
    <string name="security_settings_face_settings_use_face_unlock_phone" msgid="8720574411679475571">"Otključajte uređaj"</string>
    <string name="security_settings_face_settings_remove_face_data" msgid="3477772641643318370">"Ukloni podatke lica"</string>
    <string name="security_settings_face_settings_improve_face" msgid="1771390557275699911">"Poboljšajte podatke o licu"</string>
    <string name="security_settings_face_settings_footer" msgid="8056977398747222768">"Za otključavanje uređaja i pristup aplikacijama može se upotrijebiti vaše lice. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="security_settings_fingerprint_preference_title" msgid="2488725232406204350">"Otisak prsta"</string>
    <string name="fingerprint_manage_category_title" msgid="8293801041700001681">"Otisci prstiju"</string>
    <string name="fingerprint_usage_category_title" msgid="8438526918999536619">"Upotreba otiska prsta"</string>
    <string name="fingerprint_add_title" msgid="1926752654454033904">"Dodaj otisak prsta"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5078060939636911795">"zaključavanje zaslona"</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 postavljen</item>
      <item quantity="few"><xliff:g id="COUNT_1">%1$d</xliff:g> otiska prsta postavljena</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> otisaka prsta 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"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="7066417934622827305">"Upotreba otiska prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="3508870672887336095">"Jednostavno dodirnite senzor otiska prsta da biste otključali telefon, autorizirali kupnje ili se prijavili na aplikacije. Pazite čije otiske dodajete. Svaki otisak koji dodate može se upotrijebiti za sve te radnje.\n\nNapomena: otisak prsta nije toliko siguran kao snažan uzorak ili PIN."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="1550756694054944874">"Otključajte telefon ili odobrite kupnje otiskom prsta.\n\nNapomena: ovaj uređaj ne možete otključati otiskom prsta. Za više informacija obratite se administratoru organizacije."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="6817326798834882531">"Otključajte telefon ili odobrite kupnje otiskom prsta.\n\nNapomena: otisak prst može biti manje siguran od snažnog 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">"Dalje"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="362050541117362034">"Želite li preskočiti otisak prsta?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="958990414356204763">"Postavljanje otisaka prstiju traje samo jednu ili dvije minute. Ako to preskočite, otiske prstiju možete dodati kasnije u postavkama."</string>
    <string name="lock_screen_intro_skip_title" msgid="4988210105913705679">"Želite li preskočiti zaključavanje zaslona?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1581834104051243425">"Značajke za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge da upotrebljavaju ovaj tablet u slučaju gubitka, krađe ili vraćanja na zadano."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="4629503416877189572">"Značajke za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge da upotrebljavaju ovaj uređaj u slučaju gubitka, krađe ili vraćanja na zadano."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="2423428240245737909">"Značajke za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge da upotrebljavaju ovaj telefon u slučaju gubitka, krađe ili vraćanja na zadano."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="5219287483885558525">"Značajke za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge da upotrebljavaju ovaj tablet u slučaju gubitka ili krađe."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="1466238255429527112">"Značajke za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge da upotrebljavaju ovaj uređaj u slučaju gubitka ili krađe."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="3008526710555416125">"Značajke za zaštitu uređaja neće se uključiti. Nećete moći spriječiti druge da upotrebljavaju ovaj telefon u slučaju gubitka ili krađe."</string>
    <string name="skip_anyway_button_label" msgid="2323522873558834513">"Svejedno preskoči"</string>
    <string name="go_back_button_label" msgid="4745265266186209467">"Natrag"</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 stražnjoj strani telefona. Upotrijebite kažiprst."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="2058830032070449160">"Ilustracija uređaja i lokacije senzora otiska prsta"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7086763077909041106">"Naziv"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4150384963879569750">"U redu"</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 kada 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 biste dodali različite dijelove otiska prsta"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="7567276170287972230">"Otisak prsta dodan"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="8970048776120548976">"Kada se prikaže ta ikona, upotrijebite otisak prsta da biste se identificirali ili odobrili kupnju"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3710211704052369752">"Učinit ć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">"Odlučili ste se za otisak prsta kao jedan od načina za otključavanje telefona. Ako sad preskočite, morat ćete ga postaviti kasnije. Postavljanje traje samo otprilike jednu minutu."</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="1195743489835505376">"Postavi zaključavanje zaslona"</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">"Kažiprstom dodirnite senzor na stražnjoj strani telefona."</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">"Isteklo je vremensko ograničenje za registraciju otiska prsta. 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 prislonite neki drugi prst."</string>
    <string name="fingerprint_enroll_button_add" msgid="6317978977419045463">"Dodaj drugo"</string>
    <string name="fingerprint_enroll_button_next" msgid="6247009337616342759">"Dalje"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="2624905914239271751">"Kupnje i pristup aplikacija možete osim otključavanjem telefona autorizirati i otiskom prsta. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="7846871823167357942">" Opcija zaključavanja zaslona onemogućena je. Da biste saznali više, obratite se administratoru svoje organizacije. "<annotation id="admin_details">"Više pojedinosti"</annotation>\n\n"I dalje možete upotrebljavati otisak prsta za autorizaciju kupnji i pristup aplikacijama. "<annotation id="url">"Saznajte više"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="1888772560642539718">"Podignite prst, a zatim ponovo dodirnite senzor"</string>
    <string name="fingerprint_add_max" msgid="1020927549936895822">"Maksimalni broj otisaka prstiju koji se može dodati iznosi <xliff:g id="COUNT">%d</xliff:g>"</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 više otisaka prstiju"</string>
    <string name="fingerprint_last_delete_title" msgid="6410310101247028988">"Želite ukloniti sve otiske prstiju?"</string>
    <string name="fingerprint_delete_title" msgid="1368196182612202898">"Uklanjanje otiska prsta \"<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\""</string>
    <string name="fingerprint_delete_message" msgid="8597787803567398131">"Želite li izbrisati taj otisak prsta?"</string>
    <string name="fingerprint_last_delete_message" msgid="7852321001254275878">"Nećete moći otiskom prsta otključati telefon, autorizirati kupnje niti se prijaviti u aplikacije"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="6521520787746771912">"Nećete moći otiskom prsta otključati radni profil, autorizirati kupnje niti se prijaviti u aplikacije za posao"</string>
    <string name="fingerprint_last_delete_confirm" msgid="2634726361059274289">"Da, ukloni"</string>
    <string name="confirm_fingerprint_icon_content_description" msgid="5255544532157079096">"Nastavite pomoću otiska prsta."</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Šifriranje"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Kriptiraj tablet računalo"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Šifriraj telefon"</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, multimedijske i druge datoteke. Nakon šifriranja tableta, pod pretpostavkom da ste postavili zaključavanje zaslona (to jest obrazac, brojčani PIN ili zaporku), prilikom svakog uključivanja morat ćete otključati zaslon kako biste dešifrirali tablet. Jedini drugi način dešifriranja jest vraćanje na tvorničko stanje, čime se brišu svi vaši podaci.\n\nŠifriranje traje najmanje sat vremena. Morate započeti s punom baterijom i tijekom postupka ostaviti tablet priključen na napajanje. Ako postupak prekinete, izgubit ćete neke 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, multimedijske i druge datoteke. Nakon šifriranja telefona, pod pretpostavkom da ste postavili zaključavanje zaslona (to jest obrazac, brojčani PIN ili zaporku), prilikom svakog uključivanja morat ćete otključati zaslon kako biste dešifrirali telefon. Jedini drugi način dešifriranja jest vraćanje na tvorničko stanje, čime se brišu svi vaši podaci.\n\nŠifriranje traje najmanje sat vremena. Morate započeti s punom baterijom i tijekom postupka držati telefon priključen na napajanje. Ako prekinete postupak, izgubit ćete neke ili sve svoje podatke."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Kriptiraj tablet uređaj"</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">"Uključite punjač i pokušajte ponovo."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Nema PIN-a ili zaporke za zaključani zaslon"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Prije nego što ćete moći započeti enkripciju morat ćete postaviti PIN za zaključavanje zaslona ili zaporku."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Šifrirati?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="517662068757620756">"Postupak šifriranja nepovratan je i ako ga prekinete, izgubit ćete podatke. Šifriranje traje najmanje sat vremena, a za to vrijeme tablet će se nekoliko puta ponovo pokrenuti."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="287503113671320916">"Postupak šifriranja nepovratan je i ako ga prekinete, izgubit ćete podatke. Šifriranje traje najmanje sat vremena, a za to vrijeme telefon će se nekoliko puta ponovo pokrenuti."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Kriptiranje"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Pričekajte dok ne završi kriptiranje vašeg tabletnog računala. <xliff:g id="PERCENT">^1</xliff:g>% dovršeno."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Pričekajte dok ne završi kriptiranje telefona. <xliff:g id="PERCENT">^1</xliff:g>% dovršeno."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="1655047311546745695">"Pričekajte dok se vaš tablet kodira. 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 vaš telefon kodira. 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 i ponovo uključite."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="1794353635603020327">"Da biste otključali telefon, isključite ga i ponovo uključite."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"Upozorenje: možete pokušati otključati uređaj još <xliff:g id="COUNT">^1</xliff:g> puta. Ako ne uspijete, izbrisat će se podaci na uređaju!"</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Unesite zaporku"</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 i ne može se dovršiti. Podaci na vašem tabletu zbog toga više nisu dostupni.\n\nDa biste nastavili upotrebljavati svoj tablet, trebate ga vratiti na tvorničke postavke. Prilikom postavljanja tableta nakon vraćanja u tvorničko stanje imat ćete priliku vratiti sve podatke za koje ste na Google računu izradili sigurnosnu kopiju."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3270131542549577953">"Šifriranje je prekinuto i ne može se dovršiti. Podaci na vašem telefonu zato više nisu dostupni. \n\nDa biste nastavili upotrebljavati ​​telefon, morate ga vratiti na tvorničke postavke. Kada nakon toga postavite svoj telefon, imat ćete priliku vratiti sve podatke čije su sigurnosne kopije stvorene na vašem 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">"Unijeli ste točnu zaporku, ali su vaši podaci oštećeni. \n\nZa daljnju upotrebu tableta morate ga vratiti na tvorničke postavke. Nakon što vratite tablet na zadano, imat ćete priliku oporaviti podatke koje ste sigurnosno kopirali na svoj Google račun."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="8843311420059663824">"Unijeli ste točnu zaporku, ali su vaši podaci oštećeni. \n\nZa daljnju upotrebu telefona morate ga vratiti na tvorničke postavke. Nakon što vratite telefon na zadano, imat ćete priliku oporaviti podatke koje ste sigurnosno kopirali na svoj 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 zaslona radi zaštite tableta"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="7562847814806365373">"Postavite zaključavanje zaslona radi zaštite uređaja"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="1526355348444658181">"Postavite zaključavanje zaslona radi zaštite telefona"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="2174553391551398081">"Dodajte otisak prsta za otključavanje"</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 zaslona"</string>
    <string name="lock_settings_picker_title_profile" msgid="8822511284992306796">"Zaklj. radnim profilom"</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 telefon"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1507307757032207572">"Radi dodatne sigurnosti postavite pričuvno zaključavanje zaslona"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="8919671129189936210">"Aktivirajte značajke zaštite uređaja kako biste onemogućili drugima da upotrebljavaju ovaj tablet bez vašeg dopuštenja. Odaberite zaključavanje zaslona koje želite upotrebljavati."</string>
    <string name="setup_lock_settings_picker_message" product="device" msgid="3787276514406353777">"Aktivirajte značajke zaštite uređaja kako biste onemogućili drugima da upotrebljavaju ovaj uređaj bez vašeg dopuštenja. Odaberite zaključavanje zaslona koje želite upotrebljavati."</string>
    <string name="setup_lock_settings_picker_message" product="default" msgid="3692856437543730446">"Aktivirajte značajke zaštite uređaja kako biste onemogućili drugima da upotrebljavaju ovaj telefon bez vašeg dopuštenja. Odaberite zaključavanje zaslona koje želite upotrebljavati."</string>
    <string name="lock_settings_picker_fingerprint_message" msgid="4755230324778371292">"Odaberite pričuvni način zaključavanja zaslona"</string>
    <string name="lock_settings_picker_face_message" msgid="197106534637556054">"Odaberite pričuvni način zaključavanja zaslona"</string>
    <string name="setup_lock_settings_options_button_label" msgid="8511153243629402929">"Opcije zaključavanja zaslona"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="5058207955455973917">"Opcije zaključavanja zaslona"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Zaključavanje zaslona"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5967714169972542586">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g>/odmah nakon 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 mirovanja"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="124176557311393483">"Zaklj. radnog profila"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Promjena zaklj. zasl."</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Promijenite ili onemogućite sigurnosni uzorak, PIN ili zaporku"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Odaberite metodu za zaključavanje zaslona"</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">"Prelazak prstom"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Nema zaštite"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Uzorak"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Srednja razina sigurnosti"</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">"Zaporka"</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">"Trenutačno zaključavanje zaslona"</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 zaporka"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="1441077909803666681">"Nastavi bez otiska prsta"</string>
    <string name="fingerprint_unlock_title" msgid="2826226740306003991">"Možete otključati telefon otiskom prsta. Iz sigurnosnih razloga ta opcija zahtijeva dodatno zaključavanje zaslona."</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 + zaporka"</string>
    <string name="face_unlock_skip_face" msgid="6362883392838482791">"Nastavite bez autentifikacije licem"</string>
    <string name="face_unlock_title" msgid="9042382084472444316">"Možete otključati telefon svojim licem. Iz sigurnosnih razloga ta opcija zahtijeva dodatno zaključavanje zaslona."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2051593894736282302">"Onemogućio administrator, pravila enkripcije ili pohrana vjerodajnica"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Ništa"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Prelazak 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">"Zaporka"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="7893457665921363009">"Nakon postavljanja zaključavanja zaslona možete postaviti i otisak prsta u Postavkama &gt; Sigurnost."</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Isključi zaključavanje zaslona"</string>
    <string name="unlock_disable_frp_warning_title" msgid="264008934468492550">"Želite li 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">"Značajke zaštite uređaja neće funkcionirati bez uzorka."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2986105377420905314">"Značajke zaštite uređaja neće funkcionirati bez uzorka.<xliff:g id="EMPTY_LINE">

</xliff:g>S uređaja će se ukloniti i spremljeni otisci prstiju i nećete moći otključati telefon, autorizirati kupnje niti se prijaviti u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="586996206210265131">"Značajke zaštite uređaja neće funkcionirati bez PIN-a."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="3370462835533123695">"Značajke zaštite uređaja neće funkcionirati bez PIN-a.<xliff:g id="EMPTY_LINE">

</xliff:g>S uređaja će se ukloniti i spremljeni otisci prstiju i nećete moći otključati telefon, autorizirati kupnje niti se prijaviti u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="5420612686852555537">"Značajke zaštite uređaja neće funkcionirati bez zaporke."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="3595476296430536798">"Značajke zaštite uređaja neće funkcionirati bez zaporke.<xliff:g id="EMPTY_LINE">

</xliff:g>S uređaja će se ukloniti i spremljeni otisci prsta i nećete moći otključati telefon, autorizirati kupnje niti se prijaviti u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="1550718040483548220">"Značajke zaštite uređaja neće funkcionirati bez zaključavanja zaslona."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="3679351662094349506">"Značajke zaštite uređaja neće funkcionirati bez zaključavanja zaslona.<xliff:g id="EMPTY_LINE">

</xliff:g>S uređaja će se ukloniti i spremljeni otisci prstiju i nećete moći otključati telefon, autorizirati kupnje niti se prijaviti u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_pattern_profile" msgid="8682200103576359918">"Značajke za zaštitu profila neće funkcionirati bez uzorka."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile" msgid="6718155854303231675">"Značajke zaštite profila neće funkcionirati bez uzorka.<xliff:g id="EMPTY_LINE">

</xliff:g>S profila će se ukloniti i spremljeni otisci prstiju i nećete moći otključati profil, autorizirati kupnje niti se prijaviti u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_pin_profile" msgid="7790688070593867767">"Značajke za zaštitu profila neće funkcionirati bez PIN-a."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile" msgid="4209564603132870532">"Značajke zaštite profila neće funkcionirati bez PIN-a.<xliff:g id="EMPTY_LINE">

</xliff:g>S profila će se ukloniti i spremljeni otisci prstiju i nećete moći otključati profil, autorizirati kupnje niti se prijaviti u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_password_profile" msgid="7569285520567674461">"Značajke za zaštitu profila neće funkcionirati bez zaporke."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile" msgid="2994300676764706047">"Značajke zaštite profila neće funkcionirati bez zaporke.<xliff:g id="EMPTY_LINE">

</xliff:g>S profila će se ukloniti i spremljeni otisci prstiju i nećete moći otključati profil, autorizirati kupnje niti se prijaviti u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_content_unknown_profile" msgid="6984215718701688202">"Značajke za zaštitu profila neće funkcionirati bez zaključavanja zaslona."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile" msgid="4994062501123299418">"Značajke zaštite profila neće funkcionirati bez zaključavanja zaslona.<xliff:g id="EMPTY_LINE">

</xliff:g>S profila će se ukloniti i spremljeni otisci prstiju i nećete moći otključati profil, autorizirati kupnje niti se prijaviti u aplikacije pomoću njih."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="7075138677177748705">"Da, ukloni"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Izmijeni uzorak za otključavanje"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Promijeni PIN za otključavanje"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Promijeni zaporku za otključavanje"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="2219711062197089783">"Pokušajte ponovo. <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g>. pokušaj od <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="4277765862798876826">"Vaši će se podaci izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="1688030823464420974">"Ako pri sljedećem pokušaju unesete netočan uzorak, izbrisat će se podaci s ovog uređaja"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="5350785938296254352">"Ako pri sljedećem pokušaju unesete netočan PIN, izbrisat će se podaci s ovog uređaja"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="6208035114731421034">"Ako pri sljedećem pokušaju unesete netočnu zaporku, izbrisat će se podaci s ovog uređaja"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="7851504071368235547">"Ako pri sljedećem pokušaju unesete netočan uzorak, ovaj će se korisnik izbrisati"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="4049024921333961715">"Ako pri sljedećem pokušaju unesete netočan PIN, ovaj će se korisnik izbrisati"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="4660886542496781672">"Ako pri sljedećem pokušaju unesete netočnu zaporku, ovaj će se korisnik izbrisati"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2437716252059050291">"Ako pri sljedećem pokušaju unesete netočan uzorak, izbrisat će se vaš radni profil i njegovi podaci"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="5799931839127476913">"Ako pri sljedećem pokušaju unesete netočan PIN, izbrisat će se vaš radni profil i njegovi podaci"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="6786586046975042158">"Ako pri sljedećem pokušaju unesete netočnu zaporku, izbrisat će se vaš radni profil i njegovi podaci"</string>
    <string name="lock_failed_attempts_now_wiping_device" msgid="5047439819181833824">"Previše netočnih pokušaja. S uređaja će se izbrisati podaci."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="6188180643494518001">"Previše netočnih pokušaja. Ovaj će se korisnik izbrisati."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="1745475043685915442">"Previše netočnih pokušaja. Ovaj će se radni profil izbrisati zajedno sa svim svojim podacima."</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 barem <xliff:g id="COUNT_1">%d</xliff:g> znak</item>
      <item quantity="few">Mora sadržavati barem <xliff:g id="COUNT_1">%d</xliff:g> znaka</item>
      <item quantity="other">Mora sadržavati barem <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 barem <xliff:g id="COUNT_1">%d</xliff:g> znamenku</item>
      <item quantity="few">PIN mora sadržavati barem <xliff:g id="COUNT_1">%d</xliff:g> znamenke</item>
      <item quantity="other">PIN mora sadržavati barem <xliff:g id="COUNT_1">%d</xliff:g> znamenki</item>
    </plurals>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Nastavi"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="4581209996591221075">
      <item quantity="one">Mora sadržavati manje od <xliff:g id="NUMBER_1">%d</xliff:g> znaka</item>
      <item quantity="few">Mora sadržavati manje od <xliff:g id="NUMBER_1">%d</xliff:g> znaka</item>
      <item quantity="other">Mora sadržavati manje od <xliff:g id="NUMBER_1">%d</xliff:g> znakova</item>
    </plurals>
    <plurals name="lockpassword_pin_too_long" formatted="false" msgid="185568652740755131">
      <item quantity="one">Mora sadržavati manje od <xliff:g id="NUMBER_1">%d</xliff:g> znamenke</item>
      <item quantity="few">Mora sadržavati manje od <xliff:g id="NUMBER_1">%d</xliff:g> znamenke</item>
      <item quantity="other">Mora sadržavati manje od <xliff:g id="NUMBER_1">%d</xliff:g> znamenki</item>
    </plurals>
    <string name="lockpassword_pin_contains_non_digits" msgid="7284664023164191198">"Smije sadržavati samo znamenke od 0 do 9"</string>
    <string name="lockpassword_pin_recently_used" msgid="1401569207976460727">"Administrator uređaja ne dopušta upotrebu nedavnog PIN-a"</string>
    <string name="lockpassword_pin_blacklisted_by_admin" msgid="8563366383328811472">"Vaš je IT administrator blokirao uobičajene PIN-ove. Pokušajte s nekom drugim PIN-om."</string>
    <string name="lockpassword_illegal_character" msgid="8049611046639943217">"Unos ne smije sadržavati nevažeće znakove"</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 znamenku"</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> znamenku</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> znamenke</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> znamenki</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 simbol</item>
      <item quantity="few">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> posebna simbola</item>
      <item quantity="other">Mora sadržavati najmanje <xliff:g id="COUNT">%d</xliff:g> posebnih simbola</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 koji 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 dopušta upotrebu nedavne zaporke"</string>
    <string name="lockpassword_password_blacklisted_by_admin" msgid="9105101266246197027">"Vaš je IT administrator blokirao uobičajene zaporke. Pokušajte s nekom drugom zaporkom."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="680765285206990584">"Uzastopno rastući ili padajući slijed brojeva ili ponavljanje brojeva nije dopušteno"</string>
    <string name="lockpassword_confirm_label" msgid="8176726201389902380">"Potvrdi"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Odustani"</string>
    <string name="lockpassword_clear_label" msgid="5724429464960458155">"Izbriši"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Odustani"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Dalje"</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 predstavnici"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Za upotrebu prvo postavite zaključavanje zaslona"</string>
    <string name="manage_trust_agents_summary" msgid="1475819820389620546">"Ništa"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="3935182396726101824">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aktivni agent za pouzdanost</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aktivna agenta za pouzdanost</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aktivnih agenata za pouzdanost</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 uređaj i mogućnost otkrivanja"</string>
    <string name="bluetooth_pairing_request" msgid="2605098826364694673">"Upariti s uređajem <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="418124944140102021">"Bluetoothov kôd za uparivanje"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Unesite kôd za uparivanje pa 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 biste također trebali unijeti ovaj PIN i na drugi uređaj."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Možda ćete ovaj pristupni kôd trebati unijeti i na drugi uređaj."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Za uparivanje s:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Uvjerite se da prikazuje ovaj pristupni kôd:&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;Upariti se s ovim uređajem?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Za 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>upišite:<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> na tom uređaju pa pritisnite tipke Return ili Enter."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="9082518313285787097">"Dopustite pristup kontaktima i povijesti poziva"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_connecting_error_message" msgid="1397388344342081090">"Nije moguće povezati se na <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Skeniranjem traži uređaje"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Osvježi"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Traženje..."</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">"Internetska veza"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Tipkovnica"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Kontakti i povijest poziva"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Želite li uparivanje s ovim uređajem?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Želite li dijeliti telefonski imenik?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> želi pristupiti vašim kontaktima i povijesti poziva."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="8451248193517851958">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> traži uparivanje s Bluetoothom. Kada se poveže, moći će pristupiti kontaktima i povijesti 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"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Isključi"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Upari i poveži"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Razdvoji par"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Isključi i razdvoji par"</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 ostalim Bluetooth uređajima u blizini."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="824285504325592644">"Kada je Bluetooth uključen, uređaj može komunicirati s ostalim Bluetooth uređajima u blizini.\n\nDa bi se poboljšala učinkovitost uređaja, aplikacije i usluge mogu tražiti uređaje u blizini u bilo kojem trenutku, čak i kada je Bluetooth isključen. Na taj se način mogu, na primjer, poboljšati značajke i usluge koje se temelje na lokaciji. To možete promijeniti u "<annotation id="link">"postavkama pretraživanja"</annotation>"."</string>
    <string name="ble_scan_notify_text" msgid="1295915006005700650">"Radi poboljšanja preciznosti lokacije aplikacije i usluge sustava i dalje mogu otkriti Bluetooth uređaje. To možete promijeniti u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama traženja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_failed" msgid="4500234659813241053">"Povezivanje nije uspjelo. Pokušajte ponovo."</string>
    <string name="device_details_title" msgid="6576953269221085300">"Pojedinosti 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">"Zaboraviti uređaj?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="9087609557757135712">"Vaš telefon više neć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 više neć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 više neć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">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bit će isključen sa zvuka medija."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"Handsfree zvuk za uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bit će isključen."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bit će isključen s ulaznog uređaja."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Pristup internetu putem uređaja <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bit će prekinut."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="8355910926439312604">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bit će isključen iz dijeljenja internetske veze ovog tableta."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="6251611115860359886">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bit će isključen iz dijeljenja 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"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Povežite se s Bluetooth uređajem"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Upotrijebi za"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Preimenuj"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Svi dolazni prijenosi datoteka"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="6436258151814414028">"Povezano s uređajem 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 telefonski zvučnik"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Za glazbu i medije"</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 audiouređaja"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="5936561749790095473">"Odaberite maksimalan broj povezanih Bluetooth audiouređ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">"U blizini nema uređaja."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Povezivanje"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Povezan"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"U upotrebi"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Nedostupno"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Postavke zaslona"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Opcije bežičnog prikaza"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Zaboravi"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Gotovo"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Naziv"</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 da biste se prijavili na mrežu"</string>
    <string name="link_speed" msgid="8896664974117585555">"%1$d Mbps"</string>
    <string name="wifi_ask_enable" msgid="2795469717302060104">"<xliff:g id="REQUESTER">%s</xliff:g> želi uključiti Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="728366570145493573">"<xliff:g id="REQUESTER">%s</xliff:g> želi isključiti Wi-Fi"</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 tabletno računalo dodiruje drugi uređaj"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Dopusti razmjenu podataka kada telefon dodiruje 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 uređaja i ostalih uređaja u blizini ili ciljeva, na primjer terminala za plaćanje, čitača za pristup i interaktivnih oglasa ili oznaka."</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Spreman za prijenos sadržaja aplikacija NFC-om"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Isključeno"</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Nije dostupno 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 ta značajka uključena, sadržaj aplikacije možete prenijeti na drugi uređaj na kojem je omogućen NFC tako da uređaje postavite jedan uz drugi. Na primjer, možete prenositi web-stranice, videozapise s YouTubea, kontakte i još mnogo toga.\n\nUređaje samo postavite jedan uz drugi (prislonite im poleđine) pa dodirnite zaslon. Aplikacija određuje što će se prenijeti."</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">"Upotreba Wi-Fi-ja"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Postavke Wi-Fi-ja"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi-Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Postavljanje i upravljanje bežičnim pristupnim točkama"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Odaberite Wi‑Fi mrežu"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Uključivanje Wi-Fi-ja…"</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Isključivanje Wi-Fi-ja…"</string>
    <string name="wifi_error" msgid="3207971103917128179">"Pogreška"</string>
    <string name="wifi_sap_no_channel_error" msgid="3108445199311817111">"U ovoj zemlji nije dostupna frekvencija od 5 GHz"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"U načinu rada u zrakoplovu"</string>
    <string name="wifi_notify_open_networks" msgid="76298880708051981">"Obavijest o otvorenoj mreži"</string>
    <string name="wifi_notify_open_networks_summary" msgid="2761326999921366960">"Obavijesti kada je dostupna javna mreža visoke kvalitete"</string>
    <string name="wifi_wakeup" msgid="8815640989361538036">"Automatski uključi Wi-Fi"</string>
    <string name="wifi_wakeup_summary" msgid="2530814331062997163">"Wi‑Fi će se automatski ponovo uključiti u blizini spremljenih mreža visoke kvalitete, poput vaše kućne mreže"</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 pretraživanje Wi-Fi signala isključeno"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="108339002136866897">"Za upotrebu odaberite ocjenjivača mreže"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Izbjegavati slabe veze"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7016103106105907127">"Ne upotrebljavaj Wi-Fi mrežu ako internetska veza nije zadovoljavajuća"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="1644292503152790501">"Koristi samo mreže s dobrom internetskom vezom"</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">"Automatski se poveži s javnim mrežama visoke kvalitete"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="593964217679325831">"Za upotrebu odaberite ocjenjivača mreže"</string>
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled" msgid="8472122600853650258">"Za upotrebu 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">"Da bi se poboljšala točnost lokacije, aplikacije i usluge i dalje mogu tražiti Wi‑Fi mreže u bilo kojem trenutku, čak i kada je Wi‑Fi isključen. Na taj se način mogu, na primjer, poboljšati značajke i usluge koje se temelje na lokaciji. To možete promijeniti u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama pretraživanja<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 lokacije uključite traženje Wi-Fi-ja u <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>postavkama traženja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="7104867814641144485">"Ne prikazuj ponovno"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Zadrži Wi-Fi tijekom mirovanja"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"Wi‑Fi ostaje aktivan u mirovanju"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Pojavio se problem s promjenom postavke"</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Poboljšaj učinkovitost"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimizacija Wi-Fi-ja"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Minimiziraj potrošnju baterije kad je Wi-Fi uključen"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Ograniči bateriju za Wi‑Fi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="8593144541347373394">"Prijeđi na mobilne podatke ako Wi‑Fi izgubi pristup internetu."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="8753386877755616476">"Automatski prijeđi na mobilne podatke"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="1403505355490119307">"Koristite mobilne podatke kada Wi-Fi nema pristup internetu. Moguća je naplata potrošnje podatkovnog prometa."</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Dodaj mrežu"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2913345003906899146">"Postavke Wi‑Fi-ja"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="646393113104367290">"Wi‑Fi se automatski ponovo uključuje"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="2782566279864356713">"Wi‑Fi se ne uključuje ponovno automatski"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Wi-Fi mreže"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Više opcija"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Wi-Fi 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 s mrežom"</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">"Izmijeni mrežu"</string>
    <string name="wifi_menu_write_to_nfc" msgid="7692881642188240324">"Piši na oznaku NFC"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Da biste vidjeli dostupne mreže, uključite Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Traženje Wi-Fi mreža…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="7322372065475939129">"Nemate dopuštenje za promjenu Wi‑Fi mreže."</string>
    <string name="wifi_more" msgid="3195296805089107950">"Više"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Autom. postavljanje (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="3815269816331500375">"Uključiti traženje Wi-Fi-ja?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="6352918945128328916">"Za automatsko uključivanje Wi‑Fi-ja najprije morate uključiti traženje Wi‑Fi-ja."</string>
    <string name="wifi_settings_scanning_required_info" msgid="3155631874578023647">"Traženje Wi‑Fi-ja omogućuje aplikacijama i uslugama da traže Wi‑Fi mreže u bilo kojem trenutku, čak i kada je Wi‑Fi isključen. Na taj se način mogu, na primjer, poboljšati značajke i usluge koje se temelje 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">"Uključeno je traženje Wi‑Fi-ja"</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Napredne opcije"</string>
    <string name="wifi_advanced_toggle_description_expanded" msgid="2380600578544493084">"Napredne opcije na padajućem popisu. Dodirnite dvaput da biste saželi."</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="1463812308429197263">"Napredne opcije na padajućem popisu. Dodirnite dvaput da biste proširili."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Naziv 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">"Ako vaš usmjerivač ne emitira ID mreže, ali biste ga htjeli povezati ubuduće, mrežu možete postaviti kao skrivenu.\n\nTime bi se mogla ugroziti sigurnost jer će telefon redovito emitirati signal da bi pronašao mrežu.\n\nPostavljanjem mreže kao skrivene neće se promijeniti postavke usmjerivača."</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Jakost signala"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Status"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Brzina 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">"Spremljeno putem"</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">"2. faza provjere autentičnosti"</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">"Anoniman identitet"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Zaporka"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Pokaži zaporku"</string>
    <string name="wifi_ap_band_config" msgid="1611826705989117930">"Odaberite frekvenciju pristupne točke"</string>
    <string name="wifi_ap_choose_auto" msgid="2677800651271769965">"Automatski"</string>
    <string name="wifi_ap_choose_2G" msgid="8724267386885036210">"Frekvencija od 2,4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8813128641914385634">"Frekvencija od 5,0 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2501070491623803139">"Prednost se daje frekvenciji 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 pojas za žarišnu točku Wi‑Fi-ja:"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"IP postavke"</string>
    <string name="wifi_shared" msgid="844142443226926070">"Podijeli s drugim 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">"Upotrijebi certifikate sustava"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="5160499244977160665">"Nemoj pružiti"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4266754430576348471">"Nemoj potvrditi"</string>
    <string name="wifi_do_not_validate_eap_server_warning" msgid="1787190245542586660">"Nije naveden nijedan certifikat. Veza neće biti privatna."</string>
    <string name="wifi_ssid_too_long" msgid="3474753269579895244">"Mreža ima predugačak naziv."</string>
    <string name="wifi_no_domain_warning" msgid="5223011964091727376">"Mora navoditi 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_wps_nfc_enter_password" msgid="2288214226916117159">"Unesite mrežnu zaporku"</string>
    <string name="wifi_carrier_connect" msgid="8174696557882299911">"Wi‑Fi mreža mobilnog operatera"</string>
    <string name="wifi_carrier_content" msgid="4634077285415851933">"Povežite se putem mreže <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Radi poboljšanja preciznosti lokacije kao i u druge svrhe aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi uključiti pregledavanje mreže, čak i kada je Wi-Fi isključen.\n\nŽelite li to dozvoliti za sve aplikacije koje žele izvoditi pregledavanje?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="5538901671131941043">"Isključite putem opcije Napredno na dodatnom izborniku."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Dopusti"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Odbij"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Želite li se prijaviti radi povezivanja?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"<xliff:g id="APP_NAME">%1$s</xliff:g> zahtijeva prijavu na webu za povezivanje s mrežom."</string>
    <string name="wifi_hotspot_connect" msgid="5065506390164939225">"POVEŽI"</string>
    <string name="no_internet_access_text" msgid="5926979351959279577">"Ta mreža nema pristup internetu. Želite li ostati povezani?"</string>
    <string name="no_internet_access_remember" msgid="4697314331614625075">"Više ne pitaj za tu mrežu"</string>
    <string name="lost_internet_access_title" msgid="5779478650636392426">"Wi-Fi mreža nije povezana s internetom"</string>
    <string name="lost_internet_access_text" msgid="9029649339816197345">"U slučaju loše veze s Wi-Fi mrežom, uvijek možete prijeći na mobilnu mrežu. Mogu se naplatiti naknade za podatkovni promet."</string>
    <string name="lost_internet_access_switch" msgid="2262459569601190039">"Prelazak na mobilnu mrežu"</string>
    <string name="lost_internet_access_cancel" msgid="338273139419871110">"Ostani na Wi‑Fi-ju"</string>
    <string name="lost_internet_access_persist" msgid="7634876061262676255">"Nemoj više prikazivati"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Poveži"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Povezivanje s mrežom nije uspjelo"</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">"Spremi"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Spremanje mreže nije uspjelo"</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Odustani"</string>
    <string name="wifi_forget_dialog_title" msgid="6224151903586192426">"Zaboraviti mrežu?"</string>
    <string name="wifi_forget_dialog_message" msgid="2337060138532166680">"Izbrisat će se sve zaporke za tu mrežu"</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>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Napredni Wi-Fi"</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">"Pojedinosti 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">"Spremljene mreže"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"IP postavke"</string>
    <string name="wifi_advanced_not_available" msgid="5823045095444154586">"Napredne postavke Wi‑Fi-ja nisu dostupne za ovog korisnika"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Spremi"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Odustani"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Upišite važeću IP adresu."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Upišite važeću adresu pristupnika."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Upišite važeću DNS adresu."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Upišite prefiks mreže duljine između 0 i 32 znaka."</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">"Duljina mrežnog prefiksa"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Podaci o uređaju"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Zapamti tu vezu"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Traženje uređaja"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Traženje..."</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Preimenuj uređaj"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Paralelni 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 bilo moguće."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Preimenovanje uređaja nije uspjelo."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Isključiti?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Ako odspojite, prekinut ć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 odspojite, prekinut će se veza s uređajem <xliff:g id="PEER_NAME">%1$s</xliff:g> i <xliff:g id="PEER_COUNT">%2$s</xliff:g> te ostalim uređajima."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Otkazati pozivnicu?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Želite li otkazati pozivnicu za povezivanje s korisnikom <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">"Wi‑Fi žarišna točka"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2199911382555864644">"Internetska veza i sadržaj ne dijele se s drugim uređajima"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5936710887156133458">"Internetska veza ovog tableta dijeli se putem žarišne točke"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="default" msgid="5556202634866621632">"Internetska veza ovog telefona dijeli se putem žarišne točke"</string>
    <string name="wifi_hotspot_on_local_only_subtext" msgid="5017191966153008">"Aplikacija dijeli sadržaj. Da biste dijelili internetsku vezu, isključite žarišnu točku, a zatim je ponovo uključite"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="353306131026431089">"Zaporka nije postavljena"</string>
    <string name="wifi_hotspot_name_title" msgid="8237000746618636778">"Naziv žarišne točke"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="3378299995508671967">"Uključivanje žarišne točke <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>..."</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="3888672084861445362">"Drugi uređaji mogu se povezati sa žarišnom točkom <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_hotspot_password_title" msgid="8676859981917573801">"Zaporka žarišne točke"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="1165801173359290681">"Frekvencija pristupne točke"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="4789553667374849566">"Upotrijebite žarišnu točku da biste izradili Wi‑Fi mrežu za ostale uređaje. Žarišna točka omogućuje povezivanje s internetom putem podatkovne veze vašeg mobilnog uređaja. Mogući su dodatni troškovi za prijenos podataka na mobilnom uređaju."</string>
    <string name="wifi_hotspot_footer_info_local_only" msgid="857988412470694109">"Aplikacije mogu izraditi žarišnu točku radi dijeljenja sadržaja s uređajima u blizini."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="1590313508558948079">"Automatski isključi žarišnu točku"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="5858098059725925084">"Žarišna točka Wi‑Fi-ja isključit će se ako nije povezan nijedan uređaj"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Uključivanje žarišne točke…"</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Isključivanje žarišne točke…"</string>
    <string name="wifi_tether_enabled_subtext" msgid="7842111748046063857">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktivan"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Pogreška prijenosne Wi-Fi žarišne točke"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Postavljanje Wi-Fi žarišne točke"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Postavljanje Wi‑Fi žar. točke"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5560680057727007011">"AndroidAP WPA2 PSK žarišna točka"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"AndroidHotspot"</string>
    <string name="wifi_tether_disabled_by_airplane" msgid="414480185654767932">"Nije dostupno jer je uključen način rada u zrakoplovu"</string>
    <string name="wifi_calling_settings_title" msgid="4102921303993404577">"Wi-Fi pozivi"</string>
    <string name="wifi_calling_suggestion_title" msgid="5702964371483390024">"Proširite pozive putem Wi‑Fi-ja"</string>
    <string name="wifi_calling_suggestion_summary" msgid="1331793267608673739">"Uključite Wi-Fi pozive da biste proširili pokrivenost"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Postavka poziva"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="8149690312199253909">"Način Wi-Fi poziva"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="1565039047187685115">"Željena postavka za roaming"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (8642014873060687717) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="7800926602662078576">"Željena postavka za roaming"</string>
  <string-array name="wifi_calling_mode_choices">
    <item msgid="2124257075906188844">"Prednost ima Wi-Fi mreža"</item>
    <item msgid="1335127656328817518">"Za mobilne uređaje"</item>
    <item msgid="3132912693346866895">"Samo Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="742988808283756263">"Wi-Fi"</item>
    <item msgid="7715869266611010880">"Mobilni uređaj"</item>
    <item msgid="2838022395783120596">"Samo Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_values">
    <item msgid="4799585830102342375">"2"</item>
    <item msgid="1171822231056612021">"1"</item>
    <item msgid="3194458950573886239">"0"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_without_wifi_only">
    <item msgid="5782108782860004851">"Prednost ima Wi-Fi mreža"</item>
    <item msgid="5074515506087318555">"Za mobilne uređaje"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="6132150507201243768">"Wi-Fi"</item>
    <item msgid="1118703915148755405">"Mobilni uređaj"</item>
  </string-array>
  <string-array name="wifi_calling_mode_values_without_wifi_only">
    <item msgid="2339246858001475047">"2"</item>
    <item msgid="6200207341126893791">"1"</item>
  </string-array>
    <string name="wifi_calling_off_explanation" msgid="2597566001655908391">"Kada su Wi-Fi pozivi uključeni, telefon može usmjeravati pozive putem Wi-Fi mreža ili mreže vašeg mobilnog operatera, ovisno o vašoj želji i o tome koji je signal jači. Prije nego što uključite tu značajku, raspitajte se o naknadi i ostalim pojedinostima kod mobilnog operatera."</string>
    <string name="wifi_calling_off_explanation_2" msgid="2329334487851497223"></string>
    <string name="emergency_address_title" msgid="932729250447887545">"Adresa za hitne pozive"</string>
    <string name="emergency_address_summary" msgid="7751971156196115129">"Upotrebljava se kao vaša lokacija kada upućujete hitne pozive putem Wi‑Fi-ja"</string>
    <string name="private_dns_help_message" msgid="3299567069152568958"><annotation id="url">"Saznajte više"</annotation>" o značajkama 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 Wi-Fi pozive"</string>
    <string name="wifi_calling_turn_on" msgid="1171403510313983983">"Uključite Wi-Fi pozive"</string>
    <string name="wifi_calling_not_supported" msgid="7878640438907807754">"Wi‑Fi pozivi nisu podržani za %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">"Glasnoća"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Glazbeni efekti"</string>
    <string name="ring_volume_title" msgid="5592466070832128777">"Glasnoća zvona"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibracija ako je bešumno"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Zadani zvuk obavijesti"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Zvuk zvona"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Obavijest"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Koristi glasnoću dolaznog poziva za obavijesti"</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 obavijesti"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Mediji"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Postavite glasnoću za glazbu i videozapise"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Alarm"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Postavke zvuka za dodanu priključnu stanicu"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Tonovi biranja"</string>
    <string name="sound_effects_enable_title" msgid="4429690369187229592">"Zvukovi dodira"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Zvukovi zaključavanja zaslona"</string>
    <string name="haptic_feedback_enable_title" msgid="7152163068278526530">"Vibracija prilikom dodira"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Uklanjanje buke"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Glazba, videozapisi, igre i drugi mediji"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Melodija zvona i obavijesti"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Obavijesti"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmi"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Isključivanje zvuka zvona i obavijesti"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Isključivanje zvuka glazbe i drugih medija"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Isključivanje zvuka obavijesti"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Isključivanje zvuka 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">"Audio"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Postavke za dodanu priključnu stanicu za računalo"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Postavke za priključnu stanicu automobila"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tabletni uređaj nije priključen na priključni uređaj"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefon nije priključen"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Postavke za 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">"Prije postavljanja zvuka priključne stanice trebate na nju postaviti tabletno računalo."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Prije postavljanja zvuka priključne stanice trebate na nju postaviti telefon."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Zvuk priključivanja stanice"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Reproduciraj zvuk pri umetanju ili uklanjanju tabletnog uređaja iz priključne stanice"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Reproduciraj zvuk kod umetanja ili uklanjanja telefona s priključne stanice"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="4308252722466813560">"Ne reproduciraj zvuk pri umetanju ili uklanjanju tabletnog uređaja iz priključne stanice"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="2034927992716667672">"Ne reproduciraj zvuk kod umetanja ili uklanjanja telefona s priključne stanice"</string>
    <string name="account_settings" msgid="6403589284618783461">"Računi"</string>
    <string name="accessibility_category_work" msgid="4339262969083355720">"Računi radnih profila – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="1263518850905945594">"Računi osobnih profila"</string>
    <string name="accessibility_work_account_title" msgid="1231830766637939527">"Radni račun – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="2169071663029067826">"Osobni 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">"Prikaz"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Automatski zakreni zaslon"</string>
    <string name="color_mode_title" msgid="9186249332902370471">"Boje"</string>
    <string name="color_mode_option_natural" msgid="5013837483986772758">"Prirodno"</string>
    <string name="color_mode_option_boosted" msgid="8588223970257287524">"Pojačano"</string>
    <string name="color_mode_option_saturated" msgid="4569683960058798843">"Zasićeno"</string>
    <string name="color_mode_option_automatic" msgid="7996505473528529568">"Prilagodljivo"</string>
    <string name="color_mode_summary_natural" msgid="6624188642920403099">"Upotreba samo točnih boja"</string>
    <string name="color_mode_summary_automatic" msgid="4669516973360709431">"Odaberite žive ili točne boje"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Prebaci orijentaciju automatski pri rotaciji tabletnog uređaja"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Promijeni orijentaciju automatski kod rotacije telefona"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Prebaci orijentaciju automatski pri rotaciji tabletnog uređaja"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Promijeni orijentaciju automatski kod rotacije telefona"</string>
    <string name="brightness" msgid="8480105032417444275">"Jačina svjetline"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Svjetlina"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Podesite svjetlinu zaslona"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Prilagodljiva svjetlina"</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">"Željena je svjetlina vrlo niska"</string>
    <string name="auto_brightness_summary_low" msgid="5609877905833960427">"Željena je svjetlina niska"</string>
    <string name="auto_brightness_summary_default" msgid="7225666614394726845">"Željena je svjetlina zadana"</string>
    <string name="auto_brightness_summary_high" msgid="7172304165631136027">"Željena je svjetlina visoka"</string>
    <string name="auto_brightness_summary_very_high" msgid="979277812582279078">"Željena je svjetlina vrlo visoka"</string>
    <string name="auto_brightness_off_title" msgid="2996864829946190795">"Isključeno"</string>
    <string name="auto_brightness_very_low_title" msgid="8252988638614126320">"Vrlo niska"</string>
    <string name="auto_brightness_low_title" msgid="1632186441514863377">"Niska"</string>
    <string name="auto_brightness_default_title" msgid="936771997353506620">"Zadano"</string>
    <string name="auto_brightness_high_title" msgid="2527853305981497345">"Visoka"</string>
    <string name="auto_brightness_very_high_title" msgid="8867164854439331022">"Vrlo visoka"</string>
    <string name="auto_brightness_subtitle" msgid="6454652530864093466">"Željena razina svjetline"</string>
    <string name="auto_brightness_off_summary" msgid="7629228736838155268">"Ne prilagođavaj s obzirom na okolno osvjetljenje"</string>
    <string name="auto_brightness_very_high_summary" msgid="4551003097086220709">"Povećana potrošnja baterije"</string>
    <string name="auto_brightness_disclaimer" msgid="871436423746343406">"Optimizira razinu svjetline s obzirom na okolno osvjetljenje. Kad je ta značajka uključena, i dalje možete privremeno prilagoditi svjetlinu."</string>
    <string name="auto_brightness_description" msgid="7310335517128283729">"Svjetlina zaslona automatski će se prilagoditi vašoj okolini i aktivnostima. Klizač možete pomicati ručno kako bi prilagodljiva svjetlina dobila podatke o tome što vam odgovara."</string>
    <string name="night_display_title" msgid="2626451512200357686">"Noćno svjetlo"</string>
    <string name="night_display_text" msgid="1837277457033025056">"Noćno svjetlo boji zaslon uređaja žuto. To olakšava gledanje zaslona i čitanje pri slabom svjetlu i 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či u prilagođeno vrijeme"</string>
    <string name="night_display_auto_mode_twilight" msgid="589042813708244059">"Od zalaska do izlaska sunca"</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">"Nikad se ne uključuje automatski"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6365668239253173208">"Uključuje se automatski u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3596291693781757392">"Uključuje se automatski kad sunce zađe"</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">"Nikad se ne isključuje automatski"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="5510753572245577263">"Isključuje se automatski u <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="852270120144683507">"Isključuje se automatski kad sunce izađe"</string>
    <string name="night_display_activation_on_manual" msgid="277343561277625826">"Uključi sada"</string>
    <string name="night_display_activation_off_manual" msgid="4074557720918572883">"Odmah isključi"</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="screen_timeout" msgid="4351334843529712571">"Mirovanje"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"Zaslon se isključuje"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Kada prođe <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neaktivnosti"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Pozadinska slika"</string>
    <string name="wallpaper_settings_summary_default" msgid="3395741565658711416">"Zadano"</string>
    <string name="wallpaper_settings_summary_custom" msgid="515035303981687172">"Prilagođena"</string>
    <string name="wallpaper_suggestion_title" msgid="8583988696513822528">"Promijenite pozadinsku sliku"</string>
    <string name="wallpaper_suggestion_summary" msgid="1579144009898110491">"Prilagodite zaslon"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Odabir pozadinske slike iz"</string>
    <string name="screensaver_settings_title" msgid="1770575686476851778">"Čuvar zaslona"</string>
    <string name="screensaver_settings_summary_either_long" msgid="7302740999250873332">"Tijekom punjenja ili kada je na priključnoj stanici"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"Bilo koje od navedenog"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Tijekom 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">"Da biste kontrolirali događaje dok je telefon na priključnoj stanici i/ili dok miruje, uključite čuvar zaslona."</string>
    <string name="screensaver_settings_when_to_dream" msgid="7262410541382890146">"Kada pokrenuti"</string>
    <string name="screensaver_settings_current" msgid="4663846038247130023">"Trenutačni čuvar zaslona"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Pokreni sad"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Postavke"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Automatska svjetlina"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Aktivacija podizanjem"</string>
    <string name="ambient_display_screen_title" msgid="4252755516328775766">"Ambijentalni zaslon"</string>
    <string name="ambient_display_category_triggers" msgid="4359289754456268573">"Kada prikazati"</string>
    <string name="doze_title" msgid="2375510714460456687">"Nove obavijesti"</string>
    <string name="doze_summary" msgid="3846219936142814032">"Aktiviraj zaslon kada stigne obavijest"</string>
    <string name="doze_always_on_title" msgid="1046222370442629646">"Uvijek uključeno"</string>
    <string name="doze_always_on_summary" msgid="6978257596231155345">"Prikazivanje vremena, ikona obavijesti i drugih informacija. Povećana potrošnja baterije."</string>
    <string name="title_font_size" msgid="4405544325522105222">"Veličina fonta"</string>
    <string name="short_summary_font_size" msgid="6819778801232989076">"Smanjite ili povećajte tekst"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Postavke zaklj. 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">"Traži PIN za upotrebu tabletnog uređaja"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Potreban je PIN za upotrebu telefona"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Traži PIN za upotrebu tabletnog uređaja"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Potreban je PIN za upotrebu telefona"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Promijeni PIN za SIM"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"SIM PIN"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Zaključaj SIM karticu"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Otključaj SIM karticu"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Stari SIM PIN"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Novi SIM PIN"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Ponovo unesite novi PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"SIM PIN"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Netoč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.\nPIN je možda netočan."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"Uspješno je promijenjen PIN SIM-a"</string>
    <string name="sim_lock_failed" msgid="2489611099235575984">"Nije moguće promijeniti stanje zaključanosti SIM kartice.\nMožda je PIN pogrešan."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"U redu"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Odustani"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"Pronađeno je više SIM-ova"</string>
    <string name="sim_multi_sims_summary" msgid="2698176447067691396">"Odaberite SIM putem kojeg želite upotrebljavati mobilni prijenos podataka."</string>
    <string name="sim_change_data_title" msgid="294357201685244532">"Promijeniti podatkovni SIM?"</string>
    <string name="sim_change_data_message" msgid="5854582807996717811">"Želite li za mobilne podatke upotrijebiti <xliff:g id="NEW_SIM">%1$s</xliff:g> umjesto <xliff:g id="OLD_SIM">%2$s</xliff:g>?"</string>
    <string name="sim_preferred_title" msgid="5567909634636045268">"Ažurirati preferirani SIM?"</string>
    <string name="sim_preferred_message" msgid="8466930554330635780">"<xliff:g id="NEW_SIM">%1$s</xliff:g> je jedini SIM u vašem uređaju. Želite li upotrebljavati taj SIM za mobilne podatke, pozive i SMS poruke?"</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"Netočan PIN kôd SIM kartice; sada morate kontaktirati svog mobilnog operatera da bi otključao vaš uređaj."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="1582398808893048097">
      <item quantity="one">Netočan PIN kôd SIM kartice; imate još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaj.</item>
      <item quantity="few">Netočan PIN kôd SIM kartice; imate još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaja.</item>
      <item quantity="other">Netočan PIN kôd SIM kartice; imate još <xliff:g id="NUMBER_1">%d</xliff:g> pokušaja.</item>
    </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Operacija PIN-a SIM kartice nije uspjela!"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Ažuriranja sustava"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Verzija sustava Android"</string>
    <string name="firmware_title" msgid="5203122368389157877">"Android"</string>
    <string name="security_patch" msgid="8438384045870296634">"Razina Androidove sigurnosne zakrpe"</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">"Osnovna verzija"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Verzija jezgre"</string>
    <string name="build_number" msgid="3075795840572241758">"Broj međuverzije"</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 ostale informacije"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Telefonski broj, signal itd."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Pohranjivanje"</string>
    <string name="storage_usb_settings" msgid="7293054033137078060">"Pohrana"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Postavke pohrane"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Isključi USB memoriju, prikaži dostupnu pohranu"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Isključi SD karticu, prikaži vidljivo mjesto za 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">"Tel. broj (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">"Telefonski broj 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">"PRL verzija"</string>
    <string name="meid_multi_sim" msgid="748999971744491771">"MEID (utor za SIM %1$d)"</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 podatkovne mreže"</string>
    <string name="status_voice_network_type" msgid="5663112239742353547">"Vrsta mobilne govorne 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">"Jakost signala"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Roaming"</string>
    <string name="status_operator" msgid="2274875196954742087">"Mreža"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"MAC adresa Wi-Fi-ja"</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 bez mirovanja"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Unutarnja pohrana"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"USB memorija"</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">"Ukupno prostora"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Izračun u tijeku..."</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">"Audio (glazba, melodije zvona, podkastovi itd.)"</string>
    <string name="memory_media_misc_usage" msgid="6094866738586451683">"Ostale datoteke"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Podaci iz predmemorije"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Isklj. dijeljenu pohranu"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Isključi SD karticu"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Isključi unutarnju USB memoriju"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Isključite karticu SD radi sigurnog uklanjanja"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Umetni USB mem. za uklj."</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Umetnite SD karticu za uključivanje"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Uključi memoriju USB"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Uključivanje SD kartice"</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 memoriju"</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 unutarnjoj memoriji USB, poput glazbe ili fotografija"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Briše sve podatke na kartici SD, poput glazbe i fotografija"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Brisati podatke iz predmemorije?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Obrisat ćete predmemorirane podatke svih aplikacija."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"MTP ili PTP funkcija aktivna je"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Isključiti USB pohranu?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Isključiti SD karticu?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Ako isključite USB pohranu, neke aplikacije koje upotrebljavate zaustavit će se i mogu biti nedostupne dok ponovo ne uključite USB pohranu."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Ako isključite SD karticu, dio aplikacija koje upotrebljavate zaustavit će se i možda će biti nedostupne sve dok ponovo ne uključite 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 pohrana ne može se isključiti. Pokušajte ponovo kasnije."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3500976899159848422">"Nije moguće isključiti SD karticu. Pokušajte ponovo."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"Memorija USB bit će isključena."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"Kartica SD bit će isključena."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Isključivanje"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Isključivanje u tijeku"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Ponestaje prostora za pohranu"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Neke funkcije sustava, kao što je sinkroniziranje, može neće ispravno funkcionirati. Pokušajte osloboditi prostor brisanjem stavki ili ih otkvačite, primjerice aplikacije ili medijski sadržaj."</string>
    <string name="storage_menu_rename" msgid="7141058657592615390">"Preimenuj"</string>
    <string name="storage_menu_mount" msgid="1014683672493425425">"Učitaj"</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 prijenosnu"</string>
    <string name="storage_menu_format_private" msgid="546017531835902096">"Formatiraj kao internu"</string>
    <string name="storage_menu_migrate" msgid="3969621494238154294">"Premjesti podatke"</string>
    <string name="storage_menu_forget" msgid="6305824238997983426">"Zaboravi"</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 pohranom"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Povezivanje USB-a i računala"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Poveži kao"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Uređaj za medije (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Omogućuje prijenos medijskih datoteka u OS Windows ili Androidovim prijenosom datoteka na Mac (pogledajte www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Fotoaparat (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7406889433172511530">"Omogućuje vam prijenos fotografija pomoću softvera fotoaparata i prijenos bilo koje datoteke na računala koji ne podržavaju MTP"</string>
    <string name="usb_midi_title" msgid="3069990264258413994">"MIDI"</string>
    <string name="usb_midi_summary" msgid="539169474810956358">"Omogućuje aplikacijama omogućenima za MIDI rad putem USB-a uz MIDI softver na računalu."</string>
    <string name="storage_other_users" msgid="808708845102611856">"Drugi korisnici"</string>
    <string name="storage_internal_title" msgid="690771193137801021">"Pohrana na uređaju"</string>
    <string name="storage_external_title" msgid="3433462910096848696">"Prijenosna pohrana"</string>
    <string name="storage_volume_summary" msgid="7023441974367853372">"Iskorišteno <xliff:g id="USED">%1$s</xliff:g> 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">"Iskorišteno 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">"Učitano: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_mount_failure" msgid="1042621107954547316">"Učitavanje nije uspjelo: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="5737203344673441677">"Sigurno izbacivanje uspjelo: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_failure" msgid="5758387106579519489">"Sigurno izbacivanje nije uspjelo: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_format_success" msgid="3023144070597190555">"Formatirano: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_format_failure" msgid="6032640952779735766">"Formatiranje nije uspjelo: <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">"Medij za pohranu <xliff:g id="NAME_0">^1</xliff:g> izbačen je na siguran način, ali je još uvijek dostupan. \n\nZa upotrebu medija za pohranu <xliff:g id="NAME_1">^1</xliff:g> prvo ga morate učitati."</string>
    <string name="storage_dialog_unmountable" msgid="3732209361668282254">"Medij za pohranu <xliff:g id="NAME_0">^1</xliff:g> oštećen je. \n\nZa upotrebu medija <xliff:g id="NAME_1">^1</xliff:g> prvo ga trebate postaviti."</string>
    <string name="storage_dialog_unsupported" msgid="4503128224360482228">"Uređaj ne podržava SD karticu <xliff:g id="NAME_0">^1</xliff:g>. \n\nZa upotrebu SD kartice <xliff:g id="NAME_1">^1</xliff:g> s tim uređajem prvo je trebate postaviti."</string>
    <string name="storage_internal_format_details" msgid="4018647158382548820">"Nakon formatiranja možete upotrebljavati uređaj <xliff:g id="NAME_0">^1</xliff:g> na drugim uređajima. \n\nSvi podaci na uređaju <xliff:g id="NAME_1">^1</xliff:g> izbrisat će se. Preporučujemo vam da prvo napravite sigurnosnu kopiju. \n\n"<b>"Izrada sigurnosne kopije fotografija i ostalih medija"</b>" \nPremjestite medijske datoteke u neku drugu pohranu na ovom uređaju ili na računalo pomoću USB kabela. \n\n"<b>"Izrada sigurnosne kopije aplikacija"</b>" \nSve aplikacije pohranjene na uređaju <xliff:g id="NAME_6">^1</xliff:g> deinstalirat će se i njihovi će se podaci izbrisati. Da biste zadržali aplikacije, premjestite ih u neku drugu pohranu na ovom uređaju."</string>
    <string name="storage_internal_unmount_details" msgid="3582802571684490057"><b>"Kada izbacite uređaj <xliff:g id="NAME_0">^1</xliff:g>, aplikacije koje su pohranjene na njemu prestat će funkcionirati, a medijske datoteke pohranjene na njemu neće biti dostupne dok ga ponovo ne umetnete."</b>" \n\nUređaj <xliff:g id="NAME_1">^1</xliff:g> formatiran je tako da funkcionira samo na ovom uređaju. Neće funkcionirati na drugim uređajima."</string>
    <string name="storage_internal_forget_details" msgid="9028875424669047327">"Da biste pristupili aplikacijama, fotografijama ili podacima koje sadrži uređaj <xliff:g id="NAME">^1</xliff:g>, umetnite ga ponovo. \n\nMožete i zaboraviti tu pohranu ako uređaj nije dostupan. \n\nAko se odlučite za opciju zaborava, svi podaci koje uređaj sadrži zauvijek će se izgubiti. \n\nKasnije možete ponovo instalirati aplikacije, ali će njihovi podaci pohranjeni na tom uređaju biti izgubljeni."</string>
    <string name="storage_internal_forget_confirm_title" msgid="1370847944388479245">"Zaboraviti medij za pohranu <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="1148446041396902905">"Sve aplikacije, fotografije i podaci pohranjeni na SD kartici <xliff:g id="NAME">^1</xliff:g> trajno će se izbrisati."</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">"Videozapisi"</string>
    <string name="storage_detail_audio" msgid="1197685141676483213">"Audiozapisi"</string>
    <string name="storage_detail_cached" msgid="8547136365247818567">"Podaci iz predmemorije"</string>
    <string name="storage_detail_other" msgid="8404938385075638238">"Ostalo"</string>
    <string name="storage_detail_system" msgid="4629506366064709687">"Sustav"</string>
    <string name="storage_detail_explore" msgid="7911344011431568294">"Istraži <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_detail_dialog_other" msgid="8845766044697204852">"Ostalo uključuje dijeljene datoteke koje su spremile aplikacije, datoteke preuzete s interneta ili Bluetoothom, Android datoteke i tako dalje. \n\nDa biste vidjeli što sadrži <xliff:g id="NAME">^1</xliff:g>, dodirnite Istraži."</string>
    <string name="storage_detail_dialog_system" msgid="862835644848361569">"Sustav uključuje datoteke koje se upotrebljavaju za pokretanje verzije Androida <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_detail_dialog_user" msgid="3267254783294197804">"Korisnik <xliff:g id="USER_0">^1</xliff:g> možda je spremio fotografije, glazbu, aplikacije ili druge podatke, čime je iskorišteno <xliff:g id="SIZE">^2</xliff:g> prostora. \n\nZa prikaz pojedinosti prijeđite na račun korisnika <xliff:g id="USER_1">^1</xliff:g>."</string>
    <string name="storage_wizard_init_title" msgid="5085400514028585772">"Postavite uređaj <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="4867326438945303598">"Upotrebljavaj kao prijenosnu pohranu"</string>
    <string name="storage_wizard_init_external_summary" msgid="7476105886344565074">"Za premještanje fotografija i ostalih medijskih datoteka s jednog uređaja na drugi."</string>
    <string name="storage_wizard_init_internal_title" msgid="9100613534261408519">"Upotrebljavaj kao internu pohranu"</string>
    <string name="storage_wizard_init_internal_summary" msgid="6240417501036216410">"Za spremanje svega, uključujući aplikacije i fotografije, samo na ovom uređaju. Zahtijeva formatiranje koje sprječava rad ovog uređaja na drugim uređajima."</string>
    <string name="storage_wizard_format_confirm_title" msgid="2814021794538252546">"Formatiraj kao internu pohranu"</string>
    <string name="storage_wizard_format_confirm_body" msgid="4401758710076806509">"Potrebno je formatirati uređaj <xliff:g id="NAME_0">^1</xliff:g> radi zaštite. \n\nNakon formatiranja <xliff:g id="NAME_1">^1</xliff:g> funkcionirat će samo na ovom uređaju. \n\n"<b>"Formatiranjem se brišu svi podaci koji su trenutačno pohranjeni na <xliff:g id="NAME_2">^1</xliff:g>."</b>" Da ne biste izgubili podatke, napravite sigurnosnu kopiju."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="4905690038882041566">"Formatiraj kao prijenosnu pohranu"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="1516932692920060272">"Za to se <xliff:g id="NAME_0">^1</xliff:g> treba formatirati. \n\n"<b>"Formatiranjem će se izbrisati svi podaci koje <xliff:g id="NAME_1">^1</xliff:g> sadrži."</b>" Da ne biste izgubili podatke, napravite sigurnosnu kopiju."</string>
    <string name="storage_wizard_format_confirm_next" msgid="2774557300531702572">"Izbriši i formatiraj"</string>
    <string name="storage_wizard_format_progress_title" msgid="6487352396450582292">"Formatira se <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="3983764797223576658">"Ne uklanjajte medij <xliff:g id="NAME">^1</xliff:g> dok se formatira."</string>
    <string name="storage_wizard_migrate_title" msgid="1363078147938160407">"Preselite podatke u novu pohranu"</string>
    <string name="storage_wizard_migrate_body" msgid="890751699549542345">"Možete premjestiti svoje fotografije, datoteke i neke aplikacije na novi medij za pohranu <xliff:g id="NAME">^1</xliff:g>. \n\nPremještanje traje otprilike <xliff:g id="TIME">^2</xliff:g> i oslobodit će <xliff:g id="SIZE">^3</xliff:g> u internoj pohrani. Neke aplikacije neće funkcionirati tijekom tog postupka."</string>
    <string name="storage_wizard_migrate_now" msgid="4523444323744239143">"Premjestite odmah"</string>
    <string name="storage_wizard_migrate_later" msgid="3173482328116026253">"Premjestite kasnije"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="8564833529613286965">"Premjestite podatke odmah"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="4212060581792135962"><b>"Za premještanje je dovoljno <xliff:g id="TIME">^1</xliff:g>. Oslobodit će se <xliff:g id="SIZE">^2</xliff:g> na uređaju <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">"Premještanje podataka…"</string>
    <string name="storage_wizard_migrate_details" msgid="3709728824651136227">"Tijekom premještanja: \n• Ne uklanjajte uređaj <xliff:g id="NAME">^1</xliff:g>. \n• Neke aplikacije neće funkcionirati pravilno. \n• Ne isključujte uređaj s napajanja."</string>
    <string name="storage_wizard_ready_title" msgid="6553867088682695655">"Medij <xliff:g id="NAME">^1</xliff:g> spreman je za upotrebu"</string>
    <string name="storage_wizard_ready_external_body" msgid="2879508114260597474">"Uređaj <xliff:g id="NAME">^1</xliff:g> spreman je za upotrebu s fotografijama i ostalim medijskim uređajima."</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 fotografije, datoteke i podatke aplikacija na taj uređaj, otvorite Postavke &gt; Pohrana."</string>
    <string name="storage_wizard_move_confirm_title" msgid="292782012677890250">"Premjestite aplikaciju <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="5176432115206478941">"Premještanje aplikacije <xliff:g id="APP">^1</xliff:g> i njezinih podataka na uređaj <xliff:g id="NAME_0">^2</xliff:g> trajat će samo nekoliko trenutaka. Nećete moći upotrebljavati tu aplikaciju dok premještanje ne završi. \n\nNe uklanjajte uređaj <xliff:g id="NAME_1">^2</xliff:g> tijekom premještanja."</string>
    <string name="storage_wizard_move_unlock" msgid="1526216561023200694">"Da biste premjestili podatke, morate otključati korisnika <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="4443920302548035674">"Premještanje aplikacije <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="7802577486578105609">"Ne uklanjajte uređaj <xliff:g id="NAME">^1</xliff:g> tijekom premještanja. \n\nAplikacija <xliff:g id="APP">^2</xliff:g> na ovom uređaju neće biti dostupna dok premještanje ne završi."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="542047237524588792">"Otkaži premještanje"</string>
    <string name="storage_wizard_slow_body" msgid="8010127667184768025">"Čini se da <xliff:g id="NAME_0">^1</xliff:g> radi sporo. \n\nMožete nastaviti, no aplikacije premještene na tu lokaciju mogu zastajkivati, a prijenosi podataka mogu trajati dugo. \n\nBrža <xliff:g id="NAME_1">^1</xliff:g> mogla bi poboljšati rad."</string>
    <string name="storage_wizard_init_v2_title" msgid="8858395869710288372">"Za što će se upotrebljavati <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="4315585580670552654">"Za dodatnu pohranu na tabletu"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="570443086512059390">"Samo za aplikacije, datoteke 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">"Za dodatnu pohranu na telefonu"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="685194340141573218">"Samo za aplikacije, datoteke 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">"Za prijenosnu pohranu"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="801198071793584445">"Za prijenos datoteka i medija s jednog uređaja na drugi"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="8662451480642784031">"Prijenosna 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 medij <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="4614199613500900975">"<xliff:g id="NAME_0">^1</xliff:g> mora se formatirati radi spremanja aplikacija, datoteka i medija. \n\nFormatiranjem će se izbrisati sav postojeći sadržaj na mediju <xliff:g id="NAME_1">^2</xliff:g>. Sigurnosno kopirajte sadržaj na drugi medij <xliff:g id="NAME_2">^3</xliff:g> ili uređaj kako ga ne biste izgubili."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="8258363472135537500">"Formatiraj medij <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="31406330052996898">"Premjestiti sadržaj na medij <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4476553430145054781">"Na vanjsku pohranu <xliff:g id="NAME">^1</xliff:g> možete premjestiti datoteke, medije i određene aplikacije. \n\nPremještanjem će se osloboditi <xliff:g id="SIZE">^2</xliff:g> pohrane na tabletu, a trajat će oko <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_body" product="default" msgid="744760728669284385">"Na vanjsku pohranu <xliff:g id="NAME">^1</xliff:g> možete premjestiti datoteke, medije i određene aplikacije. \n\nPremještanjem će se osloboditi <xliff:g id="SIZE">^2</xliff:g> pohrane na telefonu, a trajat će oko <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="1239103359606165360">"Tijekom premještanja:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="7176991995007075843">"Ne uklanjajte medij <xliff:g id="NAME">^1</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="3671266712947078734">"Neke aplikacije neće funkcionirati."</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="346012901366624052">"Baterija tableta mora biti napunjena."</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="3061158350109289521">"Baterija telefona mora biti napunjena."</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">"Medij <xliff:g id="NAME">^1</xliff:g> spor je"</string>
    <string name="storage_wizard_slow_v2_body" msgid="6897444467730463117">"Medij <xliff:g id="NAME_0">^1</xliff:g> možete i dalje upotrebljavati, ali će možda biti spor. \n\nAplikacije pohranjene na mediju <xliff:g id="NAME_1">^2</xliff:g> možda neće pravilno funkcionirati, a prijenos sadržaja može trajati dugo. \n\nPokušajte upotrijebiti brži medij <xliff:g id="NAME_2">^3</xliff:g> ili upotrebljavajte ovaj medij <xliff:g id="NAME_3">^4</xliff:g> za prijenosnu 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 medij <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="4658433206901211269">"Da biste sadržaj premjestili na medij <xliff:g id="NAME">^1</xliff:g>, otvorite "<b>"Postavke &gt; Pohrana"</b></string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="6239886818487538806">"Sadržaj je premješten na medij <xliff:g id="NAME_0">^1</xliff:g>. \n\nDa biste upravljali medijem <xliff:g id="NAME_1">^2</xliff:g>, otvorite "<b>"Postavke &gt; Pohrana"</b>"."</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Status baterije"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Razina baterije"</string>
    <string name="apn_settings" msgid="3743170484827528406">"APN-ovi"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Uredi pristupnu točku"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Nije postavljeno"</string>
    <string name="apn_name" msgid="4115580098369824123">"Naziv"</string>
    <string name="apn_apn" msgid="2479425126733513353">"APN"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Proxy"</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">"Zaporka"</string>
    <string name="apn_server" msgid="2436185314756372858">"Poslužitelj"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"MMS proxy"</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 provjere autentičnosti"</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 APN-a za roaming"</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">"Nositelj"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Vrsta MVNO-a"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Vrijednost MVNO-a"</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">"Spremi"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Odbaci"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="5508155943840201232">"Polje naziva ne može biti prazno."</string>
    <string name="error_apn_empty" msgid="4932211013600863642">"APN ne može biti prazan."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"MCC polje mora imati 3 znamenke."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Polje MNC mora imati 2 ili 3 znamenke."</string>
    <string name="error_adding_apn_type" msgid="4181334016628549645">"Mobilni operater ne dopušta dodavanje APN-ova vrste %s."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Vraćanje zadanih APN postavki"</string>
    <string name="menu_restore" msgid="8260067415075573273">"Vrati na zadano"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Poništavanje zadanih postavki APN-a dovršeno."</string>
    <string name="reset_dashboard_title" msgid="6254873816990678620">"Poništavanje opcija"</string>
    <string name="reset_dashboard_summary" msgid="4851012632493522755">"Mreža, aplikacije ili uređaj mogu se poništiti"</string>
    <string name="reset_network_title" msgid="6166025966016873843">"Poništi Wi-Fi, mobilnu mrežu i Bluetooth"</string>
    <string name="reset_network_desc" msgid="5547979398298881406">"Ovime će se poništiti sve postavke mreže, uključujući:\n\n"<li>"Wi‑Fi"</li>\n<li>"mobilne podatke"</li>\n<li>"Bluetooth."</li></string>
    <string name="reset_esim_title" msgid="2419812515540592802">"Poništi i eSIM"</string>
    <string name="reset_esim_desc" msgid="6412324670559060446">"Izbrišite sve eSIM-ove na telefonu. Morat ćete se obratiti mobilnom operateru da biste ponovo preuzeli svoje eSIM-ove. Time se neće poništiti plan mobilne usluge."</string>
    <string name="reset_network_button_text" msgid="2035676527471089853">"Poništi postavke"</string>
    <string name="reset_network_final_desc" msgid="6388371121099245116">"Želite li vratiti sve postavke mreže na zadano? Tu radnju nije moguće poništiti!"</string>
    <string name="reset_network_final_button_text" msgid="1797434793741744635">"Poništi postavke"</string>
    <string name="reset_network_confirm_title" msgid="1759888886976962773">"Poništiti?"</string>
    <string name="network_reset_not_available" msgid="7188610385577164676">"Vraćanje mreže na zadano 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="1464195710538232590">"Poništavanje eSIM-ova nije uspjelo"</string>
    <string name="reset_esim_error_msg" msgid="8434956817922668388">"Poništavanje eSIM-ova nije uspjelo zbog pogreške."</string>
    <string name="master_clear_title" msgid="3531267871084279512">"Izbriši sve podatke (vraćanje na tvorničke postavke)"</string>
    <string name="master_clear_short_title" msgid="8652450915870274285">"Izbriši sve podatke (vraćanje na tvorničke postavke)"</string>
    <string name="master_clear_desc" product="tablet" msgid="9146059417023157222">"To će izbrisati sve podatke s "<b>"unutarnje pohrane"</b>" tabletnog računala, uključujući:\n\n"<li>"vaš Google račun"</li>\n<li>"podatke i postavke sustava i aplikacija"</li>\n<li>"preuzete aplikacije"</li></string>
    <string name="master_clear_desc" product="default" msgid="4800386183314202571">"To će izbrisati sve podatke s "<b>"unutarnje pohrane"</b>" telefona, uključujući:\n\n"<li>"vaš Google račun"</li>\n<li>"podatke i postavke sustava i aplikacija"</li>\n<li>"preuzete aplikacije"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Trenutačno ste prijavljeni na sljedeće račune:\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="5161423070702470742">\n\n"Na ovom uređaju postoje i drugi korisnici.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Glazba"</li>\n<li>"Fotografije"</li>\n<li>"Ostali korisnički podaci"</li></string>
    <string name="master_clear_desc_also_erases_esim" msgid="6008213558725767177"><li>"eSIM-ovi"</li></string>
    <string name="master_clear_desc_no_cancel_mobile_plan" msgid="5460926449093211144">\n\n"Time se neće otkazati vaš plan mobilne usluge."</string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Da biste izbrisali glazbu, 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 glazbu, slike i ostale korisničke podatke, trebate izbrisati "<b>"SD karticu"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Izbriši USB memoriju"</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">"Izbrisati sve podatke u unutarnjoj USB pohrani, poput glazbe ili fotografija"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Brišu se svi podaci na SD kartici, na primjer, glazba ili fotografije"</string>
    <string name="erase_esim_storage" msgid="5684858600215441932">"Izbriši eSIM"</string>
    <string name="erase_esim_storage_description" product="default" msgid="708691303677321598">"Izbrišite sve eSIM-ove na telefonu. Time se neće poništiti plan mobilne usluge."</string>
    <string name="erase_esim_storage_description" product="tablet" msgid="1780953956941209107">"Izbrišite sve eSIM-ove na tabletu. Time se neće poništiti plan mobilne usluge."</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Poništi tabletni uređaj"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Poništi telefon"</string>
    <string name="master_clear_final_desc" msgid="7318683914280403086">"Želite li izbrisati sve osobne podatke i preuzete aplikacije? Radnju nije moguće poništiti!"</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Izbriši sve"</string>
    <string name="master_clear_failed" msgid="2503230016394586353">"Nije došlo do poništavanja jer nije dostupna usluga brisanja sustava."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Poništiti?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Vraćanje na tvorničko stanje nije dostupno za ovog korisnika"</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Brisanje"</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, preusmjeravanje poziva, ID pozivatelja"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"USB dijeljenje veze"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Prijen. pristupna točka"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Dijeljenje Bluetoothom veze"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Dijeljenje veze"</string>
    <string name="tether_settings_title_all" msgid="3058586928118801157">"Žarišna točka i modemsko povezivanje"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="930464462687425777">"Žarišna točka uključena, modemsko povezivanje"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="3473671453891735907">"Žarišna točka uključena"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="1618256180720077354">"Modemsko povezivanje"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="1576908608463904152">"Dok je Štednja podatkovnog prometa uključena, ne možete upotrebljavati modemsko povezivanje ni prijenosne žarišne točke"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Dijeljenje USB-om"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3711893746716442706">"Dijelite internetsku vezu telefona putem USB-a"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="2292916486612255069">"Dijelite internetsku vezu tableta putem USB-a"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Dijeljenje veze Bluetoothom"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="8828883800511737077">"Dijelite internetsku vezu tableta putem Bluetootha"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="1904667146601254812">"Dijelite internetsku vezu 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">"Veza se ne može dijeliti s više od <xliff:g id="MAXCONNECTION">%1$d</xliff:g> uređaja."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> će biti oslobođen."</string>
    <string name="tethering_footer_info" msgid="7112228674056306147">"Pomoću žarišne točke i modemskog povezivanja drugi se uređaji mogu povezati s internetom putem podatkovne veze vašeg mobilnog uređaja. Žarišnu točku mogu izraditi i aplikacije radi dijeljenja 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">"Mobilni paket"</string>
    <string name="sms_application_title" msgid="4903928270533250448">"SMS aplikacija"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Želite li promijeniti aplikaciju za SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Želite li upotrijebiti aplikaciju <xliff:g id="NEW_APP">%1$s</xliff:g> umjesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> kao svoju aplikaciju za SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Želite li upotrijebiti aplikaciju <xliff:g id="NEW_APP">%s</xliff:g> kao svoju 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">"Želite li zamijeniti Wi‑Fi assistanta?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"Želite li upotrebljavati aplikaciju <xliff:g id="NEW_APP">%1$s</xliff:g>, a ne <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">"Želite li upotrebljavati aplikaciju <xliff:g id="NEW_APP">%s</xliff:g> za upravljanje mrežnim vezama?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Nepoznati operater SIM kartice"</string>
    <string name="mobile_no_provisioning_url" msgid="9053814051811634125">"<xliff:g id="OPERATOR">%1$s</xliff:g> nema poznatu web-lokaciju za pružanje niza usluga"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Umetnite SIM karticu i pokrenite ponovo"</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Povežite se s internetom"</string>
    <string name="location_title" msgid="1029961368397484576">"Moja lokacija"</string>
    <string name="managed_profile_location_switch_title" msgid="6712332547063039683">"Lokacija za radni profil"</string>
    <string name="location_app_level_permissions" msgid="1825588230817081339">"Dopuštenja za aplikaciju"</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Nedavni zahtjevi za lokaciju"</string>
    <string name="location_recent_location_requests_see_all" msgid="9063541547120162593">"Prikaži sve"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"Nijedna aplikacija nije nedavno zatražila lokaciju"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Usluge lociranja"</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="4408076862929611554">"Skeniranje"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="6216705505621183645">"Traženje Wi‑Fi-ja"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="2691110218127379249">"Dopustite aplikacijama i uslugama da traže Wi‑Fi mreže u bilo kojem trenutku, čak i kada je Wi‑Fi isključen. Na taj se način mogu, na primjer, poboljšati značajke i usluge koje se temelje na lokaciji."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="5444989508204520019">"Traženje Bluetootha"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="1285526059945206128">"Dopustite aplikacijama i uslugama da traže uređaje u blizini u bilo kojem trenutku, čak i kada je Bluetooth isključen. Na taj se način mogu, na primjer, poboljšati značajke i usluge koje se temelje na lokaciji."</string>
    <string name="location_network_based" msgid="9134175479520582215">"Lokacija Wi-Fi i mob. mreža"</string>
    <string name="location_neighborhood_level" msgid="5141318121229984788">"Omogućite aplik. da upotrebljavaju Googleovu uslugu lokacije za brže lociranje. Anonimni podaci prikupljat će se i slati Googleu."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Lokacija utvrđena pomoću Wi-Fi-ja"</string>
    <string name="location_gps" msgid="8392461023569708478">"GPS sateliti"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Omogućite aplikacijama da upotrebljavaju GPS na tabletnom računalu za označavanje vaše lokacije"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Omogućite aplikacijama da upotrebljavaju GPS na vašem telefonu za označavanje vaše lokacije"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Koristite potpomognuti GPS"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Koristi poslužitelj za pomoć GPS-u (isključite za smanjenje mrežnog opterećenja)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Koristi poslužitelj za pomoć GPS-u (isključite za bolji rad GPS-a)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Lokac. i Google pretraživanje"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Neka Google upotrebljava vašu lokaciju za poboljšanje 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">"Omogućite da aplikacije koje su tražile vaše dopuštenje upotrebljavaju 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 tabletnom uređaju"</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">"Suradnici"</string>
    <string name="manual" msgid="3025943393642974445">"Priručnik"</string>
    <string name="regulatory_labels" msgid="1293050314122427492">"Regulatorne oznake"</string>
    <string name="safety_and_regulatory_info" msgid="5103161279848427185">"Priručnik o sigurnosti i zakonskim propisima"</string>
    <string name="copyright_title" msgid="865906688917260647">"Autorska prava"</string>
    <string name="license_title" msgid="1990487604356037871">"Licenca"</string>
    <string name="terms_title" msgid="7697580845616764642">"Uvjeti i odredbe"</string>
    <string name="webview_license_title" msgid="2813507464175738967">"WebView licenca sustava"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Pozadine"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Davatelji satelitskih slika:\n©2014. CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="8133150693616006051">"Priručnik"</string>
    <string name="settings_manual_activity_unavailable" msgid="4752403782883814898">"Došlo je do problema prilikom učitavanja priručnika."</string>
    <string name="settings_license_activity_title" msgid="8525014571806471216">"Licence trećih strana"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Došlo je do problema 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 podatkovnu vezu. Da biste tu informaciju vidjeli sada, otvorite stranicu %s na bilo kojem računalu povezanom s internetom."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Učitavanje…"</string>
    <string name="lockpassword_choose_your_screen_lock_header" msgid="2942199737559900752">"Postavljanje zaključavanja zaslona"</string>
    <string name="lockpassword_choose_your_password_message" msgid="5377842480961577542">"Radi sigurnosti postavite zaporku"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="6624409510609085450">"Otisak prsta zahtijeva zaporku"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="5901096361617543819">"Otisak prsta zahtijeva uzorak"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="6658264750811929338">"Radi sigurnosti postavite PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="765344692615917183">"Otisak prsta zahtijeva PIN"</string>
    <string name="lockpassword_choose_your_pattern_message" msgid="8631545254345759087">"Radi sigurnosti postavite uzorak"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="1266027268220850931">"Ponovni unos zaporke"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Potvrdite uzorak"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="7744513791910572550">"Ponovni unos PIN-a"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="5140892109439191415">"Zaporke 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 iscrtajte obrazac"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Odabir načina otključavanja"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Zaporka 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">"Autentifikacija licem zahtijeva zaporku"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="8070525076987585344">"Autentifikacija licem zahtijeva uzorak"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="7304398683609714816">"Autentifikacija licem zahtijeva PIN"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="2920960858283879113">"Unesite uzorak uređaja da biste nastavili"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="4062335874438910487">"Unesite PIN uređaja da biste nastavili"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="3976394862548354966">"Unesite zaporku uređaja da biste nastavili"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="4435638308193361861">"Unesite uzorak radnog profila da biste nastavili"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="3730141667547002246">"Unesite PIN radnog profila da biste nastavili"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="4250642723467019894">"Unesite zaporku radnog profila da biste nastavili"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="530802132223800623">"Za dodatnu sigurnost upotrijebite 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 zaporku uređaja"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="3003781907040522053">"Za dodatnu sigurnost upotrijebite uzorak radnog profila"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="3367491332598821552">"Za dodatnu sigurnost unesite PIN radnog profila"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="8159775129968582940">"Za dodatnu sigurnost unesite zaporku radnog profila"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6757336656791723193">"Vaš je telefon vraćen na tvorničke postavke. Da biste ga upotrebljavali, unesite prethodni uzorak."</string>
    <string name="lockpassword_confirm_your_pin_details_frp" msgid="826520613445990470">"Vaš je telefon vraćen na tvorničke postavke. Da biste ga upotrebljavali, unesite prethodni PIN."</string>
    <string name="lockpassword_confirm_your_password_details_frp" msgid="8944081074615739040">"Vaš je telefon vraćen na tvorničke postavke. Da biste ga upotrebljavali, unesite prethodnu zaporku."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="2898036091609128286">"Potvrdite uzorak"</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 zaporku"</string>
    <string name="lockpassword_invalid_pin" msgid="15588049067548470">"Pogrešan PIN"</string>
    <string name="lockpassword_invalid_password" msgid="4038507398784975200">"Pogrešna zaporka"</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">"Izmijeni 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">"Iscrtajte uzorak za otključavanje"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Pritisnite Izbornik za pomoć."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Dignite prst kad završite"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Povežite barem <xliff:g id="NUMBER">%d</xliff:g> točke. Pokušajte ponovo."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Uzorak je snimljen"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Ponovno iscrtajte uzorak za potvrdu"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Vaš novi uzorak za otključavanje"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Potvrdi"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Iscrtajte ponovno"</string>
    <string name="lockpattern_retry_button_text" msgid="3480423193273588166">"Izbriš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">"Potreban je uzorak"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Morate iscrtati uzorak za otključavanje zaslona"</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">"Učini uzorak profila vidljivim"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="4389015658335522989">"Vibracija prilikom dodira"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Gumb napaj. zaključ. tel."</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"Osim kad 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 za otključavanje"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Izmijeni uzorak za otključavanje"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Kako iscrtati uzorak za otključavanje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="6909161623701848863">"Previše netoč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 zaslona na radnom profilu"</string>
    <string name="lock_settings_profile_unification_title" msgid="4973102698492659123">"Upotrijebi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unification_summary" msgid="7178299172998641303">"Upotreba jednog zaslona za radni profil i zaslon uređaja"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="4824620230229285301">"Želite li upotrijebiti jedno zaključavanje?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="7128305504872026659">"Uređaj će upotrebljavati zaključavanje zaslona za radni profil. Na oba će se zaključavanja primjenjivati pravila za radni profil."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="3221303098797469900">"Zaključavanje vašeg radnog profila ne udovoljava sigurnosnim zahtjevima vaše organizacije. Možete upotrebljavati isto zaključavanje zaslona za uređaj i radni profil, no primjenjivat će se pravila zaključavanja zaslona za radni profil."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="8249970828159656518">"Upotrijebi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="5943758576756482777">"Upotrijebi jedno zaključavanje"</string>
    <string name="lock_settings_profile_unified_summary" msgid="9008819078132993492">"Isto kao i zaključavanje zaslona na uređaju"</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Upravljanje aplikacijama"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Upravljanje instaliranim aplikacijama i njihovo uklanjanje"</string>
    <string name="applications_settings" msgid="5281808652705396152">"Informacije o aplikaciji"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Upravljanje aplikacijama, postavljanje prečaca 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 otvorene aplikacije"</string>
    <string name="see_all_apps_title" msgid="1317153498074308438">"Pogledajte sve aplikacije (<xliff:g id="COUNT">%1$d</xliff:g>)"</string>
    <string name="install_all_warning" product="tablet" msgid="8310489909586138165">"Vaš tablet i osobni podaci izloženiji su napadima nepoznatih aplikacija. Instaliranjem aplikacija iz takvog izvora prihvaćate odgovornost za svu štetu nastalu na tabletu  ili gubitak podataka uzrokovan upotrebom tih aplikacija."</string>
    <string name="install_all_warning" product="default" msgid="1952257127370115988">"Vaš telefon i osobni podaci izloženiji su napadima nepoznatih aplikacija. Instaliranjem aplikacija iz takvog izvora prihvaćate odgovornost za svu štetu nastalu na telefonu ili gubitak podataka uzrokovan upotrebom tih aplikacija."</string>
    <string name="install_all_warning" product="device" msgid="3648003301476423145">"Vaš uređaj i osobni podaci izloženiji su napadima nepoznatih aplikacija. Instaliranjem aplikacija iz ovog izvora prihvaćate odgovornost za svu štetu nastalu na uređaju ili gubitak podataka uzrokovan upotrebom tih aplikacija."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Napredne postavke"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Omogućiti više opcija postavki"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Info o aplikaciji"</string>
    <string name="storage_label" msgid="8700867073480107253">"Prostor za pohranu"</string>
    <string name="auto_launch_label" msgid="2669236885531442195">"Otvori prema zadanim postavkama"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Zadane postavke"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Kompatibilnost zaslona"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Dozvole"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Predmemorija"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Očisti predmemoriju"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Predmemorija"</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">"Izbriši pristup"</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">"USB aplikacija za pohranu"</string>
    <string name="data_size_label" msgid="6117971066063850416">"Podaci korisnika"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"USB uređaj za pohranu podataka"</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">"Izbriši pohranu"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Deinstaliraj ažuriranja"</string>
    <string name="auto_launch_enable_text" msgid="4275746249511874845">"Odlučili ste da se ta aplikacija pokreće prema zadanim postavkama za neke radnje."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="566822577792032925">"Odlučili ste dopustiti ovoj aplikaciji izradu widgeta i pristupanje njihovim podacima."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Nema zadanih postavki."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Izbriši zadane postavke"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Ta aplikacija možda nije dizajnirana za vaš zaslon. Ovdje možete provjeriti kako se prilagođava vašem zaslonu."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Pitaj pri pokretanju"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Skaliranje aplikacije"</string>
    <string name="unknown" msgid="1592123443519355854">"Nepoznato"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Poredaj prema nazivu"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Poredaj po veličini"</string>
    <string name="sort_order_recent_notification" msgid="6064103501358974282">"Najnovije"</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 predmemorije"</string>
    <string name="default_emergency_app" msgid="1951760659640369980">"Aplikacija za hitne slučajeve"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Poništi postavke apl."</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Poništiti postavke?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"Sve sljedeće preferencije vratit će se na zadane postavke:\n\n "<li>"onemogućene aplikacije"</li>\n" "<li>"onemogućene obavijesti aplikacija"</li>\n" "<li>"zadane aplikacije za radnje"</li>\n" "<li>"ograničenja pozadinskih podataka za aplikacije"</li>\n" "<li>"sva ograničenja dozvola"</li>\n\n" Podatke aplikacija nećete izgubiti."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Poništi aplikacije"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Upravljaj prostorom"</string>
    <string name="filter" msgid="2018011724373033887">"Filtar"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Odabir opcije filtra"</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">"Pokrenuto"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Memorija USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Na SD kartici"</string>
    <string name="not_installed" msgid="2797554494953450291">"Nije instalirano za korisnika"</string>
    <string name="installed" msgid="3070865169422600098">"Instalirano"</string>
    <string name="no_applications" msgid="7336588977497084921">"Nema aplikacija."</string>
    <string name="internal_storage" msgid="1584700623164275282">"Unutarnja pohrana"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Ponovni izračun veličine…"</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Izbrisati podatke aplikacije?"</string>
    <string name="clear_data_dlg_text" msgid="3951297329833822490">"Svi podaci ove aplikacije bit će trajno izbrisani. To uključuje sve datoteke, postavke, račune, baze podataka itd."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"U redu"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Odustani"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="4893589904687340011">"Aplikacija nije pronađena na popisu instaliranih aplikacija."</string>
    <string name="clear_failed_dlg_text" msgid="8651231637137025815">"Brisanje pohrane za aplikaciju nije uspjelo."</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">"Izračunavanje..."</string>
    <string name="invalid_size_value" msgid="1582744272718752951">"Nije 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 tabletni uređaj"</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 memoriju"</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">"U tijeku je neko drugo premještanje."</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="app_forward_locked" msgid="6331564656683790866">"Aplikacija ima zaštitu protiv kopiranja."</string>
    <string name="invalid_location" msgid="4354595459063675191">"Lokacija instalacije nije važeća."</string>
    <string name="system_package" msgid="1352722848400644991">"Ažuriranja sustava nije moguće instalirati na vanjskom mediju."</string>
    <string name="move_error_device_admin" msgid="8673026002690505763">"Administrator uređaja ne može se 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 silom zaustavite aplikaciju, možda će se ponašati nepredviđeno."</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Željena lokacije instalacije"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Promijenite željenu lokaciju instalacije za nove aplikacije."</string>
    <string name="app_disable_dlg_positive" msgid="7375627244201714263">"Onemogući aplikaciju"</string>
    <string name="app_disable_dlg_text" msgid="5632072173181990531">"Ako onemogućite tu aplikaciju, Android i druge aplikacije možda više neće funkcionirati pravilno."</string>
    <string name="app_special_disable_dlg_title" msgid="2690148680327142674">"Izbrisati podatke i onemogućiti aplikaciju?"</string>
    <string name="app_special_disable_dlg_text" msgid="5832078825810635913">"Ako onemogućite tu aplikaciju, Android i druge aplikacije možda više neće funkcionirati pravilno, a izbrisat će se i vaši podaci."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Isključiti obavijesti?"</string>
    <string name="app_install_details_group_title" msgid="7084623031296083574">"Trgovina"</string>
    <string name="app_install_details_title" msgid="6905279702654975207">"Pojedinosti o aplikaciji"</string>
    <string name="app_install_details_summary" msgid="6464796332049327547">"Aplikacija instalirana iz trgovine <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="4529934403276907045">"Više informacija o aplikaciji <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"U tijeku"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Nikada nije upotrebljavano)"</string>
    <string name="no_default_apps" msgid="2915315663141025400">"Nema zadanih aplikacija."</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Upotreba pohrane"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Prikaz pohrane koju upotrebljavaju aplikacije"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Ponovno pokretanje"</string>
    <string name="cached" msgid="1059590879740175019">"Pozadinski proces u predmemoriji"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Ništa se ne izvodi."</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">"<xliff:g id="MEMORY">%1$s</xliff:g> slobodno"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> up."</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">"Uklonjeni 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> usluga"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"Broj procesa: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, broj usluga: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesa i <xliff:g id="NUMSERVICES">%2$d</xliff:g> usluga"</string>
    <string name="running_processes_header_title" msgid="6588371727640789560">"Memorija uređaja"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Upotreba RAM-a za aplikacije"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Sustav"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Aplikacije"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"Dostupno"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Iskorišteno"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"U predmemoriji"</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 je uslugu pokrenula njezina aplikacija. Zaustavljanje može uzrokovati pad aplikacije."</string>
    <string name="heavy_weight_stop_description" msgid="6050413065144035971">"Ova se aplikacija ne može sigurno zaustaviti. Ako je zaustavite, mogli biste izgubiti trenutačan rad."</string>
    <string name="background_process_stop_description" msgid="3834163804031287685">"Ovo je proces stare aplikacije koja se još uvijek izvršava u slučaju da opet bude potrebna. Obično je nema potrebe zaustavljati."</string>
    <string name="service_manage_description" msgid="479683614471552426">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: trenutačno u upotrebi. Dodirnite Postavke da biste upravljali."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Glavni proces u upotrebi."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Usluga <xliff:g id="COMP_NAME">%1$s</xliff:g> u upotrebi je."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Pružatelj <xliff:g id="COMP_NAME">%1$s</xliff:g> u upotrebi je."</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 značajke vašeg tabletnog računala mogu prestati raditi ispravno dok ga ne isključite i ponovo ne uključite."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Ako zaustavite ovu uslugu, neke značajke vašeg telefona mogu prestati raditi ispravno dok ga ne isključite i ponovo ne uključite."</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 dopuštenje za promjenu jezika na uređaju."</string>
    <string name="language_keyboard_settings_title" msgid="3709159207482544398">"Jezici i unos"</string>
    <string name="input_assistance" msgid="7577795275222555487">"Pomoć pri unosu"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Tipkovnica 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">"Autom. veliko poč. sl."</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Postavi veliko slovo na početku rečenice"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Automatsko stavljanje interpunkcije"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Postavke fizičke tipkovnice"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Pritisnite razmaknicu dvaput za umetanje \".\""</string>
    <string name="show_password" msgid="4837897357002495384">"Prikaži zaporke"</string>
    <string name="show_password_summary" msgid="3365397574784829969">"Nakratko prikaži znakove tijekom unosa"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Ovaj alat za provjeru pravopisa može prikupljati sav tekst koji upisujete, uključujući osobne podatke kao što su zaporke i brojevi kreditnih kartica. Dolazi s aplikacije <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Upotrebljavati taj 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="6035224122054465137">"Tipkovnica i unosi"</string>
    <string name="virtual_keyboard_category" msgid="1012830752318677119">"Virtualna tipkovnica"</string>
    <string name="available_virtual_keyboard_category" msgid="7645766574969139819">"Dostupna virtualna tipkovnica"</string>
    <string name="add_virtual_keyboard" msgid="3302152381456516928">"Upravljanje tipkovnicama"</string>
    <string name="keyboard_assistance_category" msgid="5843634175231134014">"Pomoć za tipkovnicu"</string>
    <string name="physical_keyboard_title" msgid="8285149877925752042">"Fizička tipkovnica"</string>
    <string name="show_ime" msgid="2658582193437188227">"Prikaži virtualnu tipkovnicu"</string>
    <string name="show_ime_summary" msgid="8164993045923240698">"Zadržava se na zaslonu dok je fizička tipkovnica aktivna"</string>
    <string name="keyboard_shortcuts_helper" msgid="4839453720463798145">"Pomoć za tipkovne prečace"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5871299901459743288">"Prikaz dostupnih prečaca"</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">"Upravljač igrama"</string>
    <string name="vibrate_input_devices" msgid="421936611134697943">"Preusmjeri vibraciju"</string>
    <string name="vibrate_input_devices_summary" msgid="82093256723774584">"Pošalji vibraciju igraćem kontroleru kada su povezani"</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Odaberite izgled tipkovnice"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Postavljanje izgleda tipkovnice"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Za prijelaz pritisnite Ctrl i razmaknicu."</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Zadano"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Izgledi tipkovnice"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Osobni rječnik"</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">"U redu"</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čac:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Jezik:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Upišite riječ"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Neobavezni prečac"</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 biste dodali riječ, dodirnite gumb 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 tabletnom uređaju"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Telefonske informacije"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Unos teksta"</string>
    <string name="input_method" msgid="5434026103176856164">"Način ulaza"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Trenutačna tipkovnica"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Selektor načina ulaza"</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">"Postavljanje načina 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">"Odabir aktivnih načina unosa"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Postavke zaslonske tipkovnice"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Fizička tipkovnica"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Postavke fizičke tipkovnice"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Odaberi gadget"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Odaberite widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Želite izraditi widget i dozvoliti pristup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Kada izradite widget, aplikacija <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> može pristupiti svim podacima koje taj widget prikazuje."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Uvijek dopusti aplikaciji <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> izradu widgeta i pristupanje njihovim podacima"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Korisnička statistika"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Korisnička statistika"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Poredati prema:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplikacija"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Posljednja upotreba"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Vrijeme upotrebe"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Pristupačnost"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Postavke dostupnosti"</string>
    <string name="accessibility_settings_summary" msgid="981260486011624939">"Čitači zaslona, zaslon, kontrole interakcije"</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. Značajke pristupačnosti možete promijeniti kasnije u postavkama."</string>
    <string name="vision_settings_suggestion_title" msgid="8058794060304707004">"Promjena veličine fonta"</string>
    <string name="screen_reader_category_title" msgid="7739154903913400641">"Čitači zaslona"</string>
    <string name="audio_and_captions_category_title" msgid="3420727114421447524">"Audio i tekst na zaslonu"</string>
    <string name="display_category_title" msgid="685461049938269166">"Zaslon"</string>
    <string name="interaction_control_category_title" msgid="7836591031872839151">"Kontrole interakcije"</string>
    <string name="user_installed_services_category_title" msgid="6426376488922158647">"Preuzete usluge"</string>
    <string name="experimental_category_title" msgid="5272318666666893547">"Eksperimentalno"</string>
    <string name="feature_flags_dashboard_title" msgid="778619522682769966">"Oznake značajki"</string>
    <string name="talkback_title" msgid="7912059827205988080">"TalkBack"</string>
    <string name="talkback_summary" msgid="8331244650729024963">"Čitač zaslona namijenjen prvenstveno slijepim i slabovidnim osobama"</string>
    <string name="select_to_speak_summary" msgid="4282846695497544515">"Dodirnite stavke na zaslonu da bi ih usluga izgovorila naglas"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Titlovi"</string>
    <string name="accessibility_screen_magnification_title" msgid="6001128808776506021">"Povećavanje"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3719929521571489913">"Povećavanje trostrukim dodirom"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="7141753038957538230">"Povećavanje gumbom"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="2760906043221923793">"Povećavanje gumbom i trostrukim dodirom"</string>
    <string name="accessibility_preference_magnification_summary" msgid="5867883657521404509">"Povećavanje zaslona"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="3411979839172752057">"Dodirnite triput za zumiranje"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="3693116360267980492">"Dodirnite gumb za zumiranje"</string>
    <string name="accessibility_screen_magnification_summary" msgid="5258868553337478505"><b>"Da biste zumirali"</b>", brzo dodirnite zaslon tri puta.\n"<ul><li>"Povlačite s dva prsta ili više njih da biste se pomicali"</li>\n<li>"Spojite dva prsta ili više njih da biste prilagodili zumiranje"</li></ul>\n\n<b>"Da biste privremeno zumirali"</b>", brzo dodirnite zaslon tri puta i zadržite prst dolje nakon trećeg dodira.\n"<ul><li>"Povlačite prstom da biste se kretali zaslonom"</li>\n<li>"Podignite prst da biste smanjili prikaz"</li></ul>\n\n"Tipkovnica i navigacijska traka ne mogu se povećati."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="1996584694050087161">"Kad je povećavanje uključeno, upotrijebite gumb Pristupačnost na dnu zaslona za brzo povećavanje.\n\n"<b>"Da biste zumirali"</b>", dodirnite gumb Pristupačnost, a zatim dodirnite bilo gdje na zaslonu.\n"<ul><li>"Povlačite s dva prsta ili više njih da biste se pomicali"</li>\n<li>"Spojite dva prsta ili više njih da biste prilagodili zumiranje"</li></ul>\n\n<b>"Da biste privremeno zumirali"</b>", dodirnite gumb Pristupačnost, a zatim dodirnite i zadržite bilo gdje na zaslonu.\n"<ul><li>"Povlačite prstom da biste se kretali zaslonom"</li>\n<li>"Podignite prst da biste smanjili prikaz"</li></ul>\n\n"Tipkovnica i navigacijska traka ne mogu se povećati."</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="70533120652758190">"Gumb Pristupačnost postavljen je na <xliff:g id="SERVICE">%1$s</xliff:g>. Da biste upotrijebili povećanje, dodirnite i zadržite gumb Pristupačnost i zatim odaberite povećanje."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="2048884356166982714">"Prečac tipki za glasnoću"</string>
    <string name="accessibility_shortcut_service_title" msgid="4779360749706905640">"Usluga prečaca"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="5490636079625489534">"Dopusti sa zaključanog zaslona"</string>
    <string name="accessibility_shortcut_description" msgid="1765853731190717372">"Kad je taj prečac uključen, možete na tri sekunde pritisnuti obje tipke za glasnoću kako biste pokrenuli značajku pristupačnosti."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Tekst s visokim kontrastom"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Autom. ažuriranje uvećanja zaslona"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Ažuriranje uvećanja zaslona pri izmjeni aplikacija"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Tipka za uklj. 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">"Monoaudio"</string>
    <string name="accessibility_toggle_master_mono_summary" msgid="5634277025251530927">"Kombiniranje kanala prilikom reprodukcije zvuka"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Trajanje pritiska"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Inverzija boja"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="7052959202195368109">"Može utjecati na izvedbu"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2434062071927416098">"Vrijeme zadržavanja"</string>
    <string name="accessibility_autoclick_description" msgid="4908960598910896933">"Ako upotrebljavate miš, pokazivač možete postaviti tako da se radnja izvrši automatski kada se miš ne pomiče 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">"Vibracije"</string>
    <string name="accessibility_notification_vibration_title" msgid="660829933960942244">"Zvonjenje i vibracija za obavijesti"</string>
    <string name="accessibility_touch_vibration_title" msgid="7931823772673770492">"Vibracija za dodir"</string>
    <string name="accessibility_service_master_switch_title" msgid="6835441300276358239">"Upotreba usluge"</string>
    <string name="accessibility_daltonizer_master_switch_title" msgid="8655284637968823154">"Upotreba korekcije boje"</string>
    <string name="accessibility_caption_master_switch_title" msgid="4010227386676077826">"Upotreba titlova"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="974461729380409972">"Nastavi"</string>
    <string name="accessibility_hearingaid_title" msgid="8312145423610648518">"Slušni aparati"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="6240237523789614599">"Nije povezan nijedan slušni aparat"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="6371077608778830020">"Dodavanje slušnog aparata"</string>
    <string name="accessibility_hearingaid_pair_instructions_first_message" msgid="3912093691643131154">"Za uparivanje slušnih aparata pronađite i dodirnite uređaj na sljedećem zaslonu."</string>
    <string name="accessibility_hearingaid_pair_instructions_second_message" msgid="5596683393607650243">"Provjerite je li slušni aparat u načinu uparivanja."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="1246354030808703545">"Uređaj <xliff:g id="DEVICE_NAME">%1$s</xliff:g> trenutačno je aktivan"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="3160782397139295486">
      <item quantity="one">Spremljen je <xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> slušni aparat</item>
      <item quantity="few">Spremljena su <xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> slušna aparata</item>
      <item quantity="other">Spremljeno je <xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> slušnih aparata</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">"Usluga ne radi. Dodirnite za informacije."</string>
    <string name="accessibility_description_state_stopped" msgid="6953539746047006596">"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 korekcije"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_extremely_short_delay" formatted="false" msgid="7340347830562315800">
      <item quantity="one">Izrazito kratka odgoda (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Izrazito kratka odgoda (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Izrazito kratka odgoda (<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">Vrlo kratka odgoda (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Vrlo kratka odgoda (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Vrlo kratka odgoda (<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">Kratka odgoda (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Kratka odgoda (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Kratka odgoda (<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">Duga odgoda (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Duga odgoda (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Duga odgoda (<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">Vrlo duga odgoda (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Vrlo duga odgoda (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Vrlo duga odgoda (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <string name="accessibility_vibration_summary" msgid="1372393829668784669">"Zvono <xliff:g id="SUMMARY_RING">%1$s</xliff:g>, dodir <xliff:g id="SUMMARY_TOUCH">%2$s</xliff:g>"</string>
    <string name="accessibility_vibration_summary_off" msgid="1753566394591809629">"Zvonjenje i obavijesti postavljeni na isključeno"</string>
    <string name="accessibility_vibration_summary_low" msgid="7628418309029013867">"Zvonjenje i obavijesti postavljeni na nisko"</string>
    <string name="accessibility_vibration_summary_medium" msgid="3422136736880414093">"Zvonjenje i obavijesti postavljeni na srednje"</string>
    <string name="accessibility_vibration_summary_high" msgid="3239807793182635729">"Zvonjenje i obavijesti postavljeni na visoko"</string>
    <string name="accessibility_vibration_intensity_off" msgid="4613890213008630847">"Isključeno"</string>
    <string name="accessibility_vibration_intensity_low" msgid="2017572546489862987">"Nisko"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="3782136025830279769">"Srednje"</string>
    <string name="accessibility_vibration_intensity_high" msgid="2543921139337952491">"Visoko"</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">"Zasjenjenost pozadine"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Boja pozadine titlova"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Neprozirnost pozadine titlova"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Boja teksta"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Neprozirnost teksta"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Boja ruba"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Vrsta ruba"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Obitelj fonta"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Titlovi ć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">"Ništa"</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">"Grimizna"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Želite li upotrijebiti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"<xliff:g id="SERVICE">%1$s</xliff:g> treba sljedeće:"</string>
    <string name="touch_filtered_warning" msgid="8644034725268915030">"Budući da aplikacija prekriva zahtjev za dopuštenje, Postavke ne mogu potvrditi vaš odgovor."</string>
    <string name="enable_service_encryption_warning" msgid="3064686622453974606">"Ako uključite <xliff:g id="SERVICE">%1$s</xliff:g>, vaš uređaj neće upotrebljavati PIN ili zaporku za zaključavanje zaslona za bolje šifriranje podataka."</string>
    <string name="secure_lock_encryption_warning" msgid="460911459695077779">"Budući da ste uključili uslugu pristupačnosti, vaš uređaj neće upotrebljavati PIN ili zaporku za zaključavanje zaslona za bolje šifriranje podataka."</string>
    <string name="enable_service_pattern_reason" msgid="777577618063306751">"Budući da uključivanje usluge <xliff:g id="SERVICE">%1$s</xliff:g> utječe na enkripciju podataka, morate potvrditi uzorak."</string>
    <string name="enable_service_pin_reason" msgid="7882035264853248228">"Budući da uključivanje usluge <xliff:g id="SERVICE">%1$s</xliff:g> utječe na enkripciju podataka, morate potvrditi PIN."</string>
    <string name="enable_service_password_reason" msgid="1224075277603097951">"Budući da uključivanje usluge <xliff:g id="SERVICE">%1$s</xliff:g> utječe na enkripciju podataka, morate potvrditi zaporku."</string>
    <string name="capability_title_receiveAccessibilityEvents" msgid="1869032063969970755">"Pratiti vaše radnje"</string>
    <string name="capability_desc_receiveAccessibilityEvents" msgid="6640333613848713883">"Dobit će obavijest kad stupite u interakciju s nekom aplikacijom."</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Želite li zaustaviti uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="2247101878627941561">"Ako dodirnete \"U redu\", zaustavit će se <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Nema instaliranih usluga"</string>
    <string name="accessibility_no_service_selected" msgid="2840969718780083998">"Nije odabrana nijedna usluga"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Nije dan opis."</string>
    <string name="settings_button" msgid="3006713718908152930">"Postavke"</string>
    <string name="print_settings" msgid="4742428530112487843">"Ispis"</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 ispisa</item>
      <item quantity="few">Uključene su <xliff:g id="COUNT">%1$d</xliff:g> usluge ispisa</item>
      <item quantity="other">Uključeno je <xliff:g id="COUNT">%1$d</xliff:g> usluga ispisa</item>
    </plurals>
    <plurals name="print_jobs_summary" formatted="false" msgid="5810106725778525400">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> zadatak ispisa</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> zadatka ispisa</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> zadataka ispisa</item>
    </plurals>
    <string name="print_settings_title" msgid="3685449667822217816">"Usluge ispisa"</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 pisač"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Postavke"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Dodavanje pisača"</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">"Dodaj uslugu"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Dodaj pisač"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Pretraži"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Traženje pisača"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Usluga je onemogućena"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Zadaci ispisa"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Zadatak ispisa"</string>
    <string name="print_restart" msgid="8373999687329384202">"Ponovo pokreni"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Odustani"</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 zadatka <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Ispisivanje zadatka <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Otkazivanje zadatka <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Pogreška pisača <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Pisač 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 prikazan je"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Okvir za pretraživanje skriven je"</string>
    <string name="printer_info_desc" msgid="5824995108703060003">"Više informacija o ovom pisaču"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Baterija"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Što troši bateriju"</string>
    <string name="power_usage_not_available" msgid="3109326074656512387">"Podaci o upotrebi baterije nedostupni."</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 je <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 dovršetka punjenja"</string>
    <string name="background_activity_title" msgid="8482171736539410135">"Ograničenje upotrebe u pozadini"</string>
    <string name="background_activity_summary" msgid="8140094430510517362">"Dopustite rad aplikacije u pozadini"</string>
    <string name="background_activity_summary_disabled" msgid="3710669050484599847">"Aplikaciji nije dopušten rad u pozadini"</string>
    <string name="background_activity_summary_whitelisted" msgid="1079899502347973947">"Upotreba u pozadini ne može se ograničiti"</string>
    <string name="background_activity_warning_dialog_title" msgid="2216249969149568871">"Želite li ograničiti pozadinsku aktivnost?"</string>
    <string name="background_activity_warning_dialog_text" msgid="7049624449246121981">"Ako ograničite pozadinsku aktivnost za aplikaciju, možda će se ponašati nepredviđeno"</string>
    <string name="background_activity_disabled_dialog_text" msgid="6133420589651880824">"Aplikacija nije postavljena za optimizaciju baterije, pa je ne možete ograničiti.\n\nZa ograničenje uključite optimizaciju."</string>
    <string name="device_screen_usage" msgid="3386088035570409683">"Upotreba zaslona od potpunog punjenja"</string>
    <string name="power_usage_list_summary" msgid="5584049564906462506">"Upotreba baterije od potpunog punjenja"</string>
    <string name="screen_usage_summary" msgid="6687403051423153550">"Količina vremena dok je zaslon bio uključen od posljednjeg punjenja"</string>
    <string name="device_usage_list_summary" msgid="5623036661468763251">"Upotreba uređaja od potpunog punjenja"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Upotreba baterije nakon isključivanja"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Upotreba baterije od poništavanja"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> na bateriji"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> od isključivanja"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Punjenje"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Zaslon 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">"Fotoaparat uključen"</string>
    <string name="battery_stats_flashlight_on_label" msgid="4319637669889411307">"Bljeskalica uključena"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Budan"</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 budnosti 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 povijesti"</string>
    <string name="battery_details_title" msgid="6101394441569858580">"Potrošnja baterije"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Detalji upotrebe"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Podesi potrošnju energije"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Uključeni paketi"</string>
    <string name="battery_tip_summary_title" msgid="368729969313047399">"Aplikacije se izvode na uobičajen način"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="2198778125778121221">"Telefon troši bateriju u pozadini uobičajenom brzinom"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="1183976728682325345">"Tablet troši bateriju u pozadini uobičajenom brzinom"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="363718204492523920">"Uređaj troši bateriju u pozadini uobičajenom brzinom"</string>
    <string name="battery_tip_low_battery_title" msgid="5103420355109677385">"Slaba baterija"</string>
    <string name="battery_tip_low_battery_summary" msgid="4702986182940709150">"Baterija će se uskoro isprazniti"</string>
    <string name="battery_tip_smart_battery_title" product="default" msgid="2542822112725248683">"Poboljšajte trajanje baterije telefona"</string>
    <string name="battery_tip_smart_battery_title" product="tablet" msgid="6452567046912954866">"Poboljšajte trajanje baterije tableta"</string>
    <string name="battery_tip_smart_battery_title" product="device" msgid="4445149029390556382">"Poboljšajte trajanje baterije uređaja"</string>
    <string name="battery_tip_smart_battery_summary" msgid="2326809294592208069">"Uključite Battery Manager"</string>
    <string name="battery_tip_early_heads_up_title" msgid="5788492366387119807">"Uključite Štednju baterije"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="1639271439914224547">"Baterija bi se mogla isprazniti brže nego obično"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="4294083319255926811">"Štednja baterije je uključena"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7054036010928794364">"Neke značajke mogu biti ograničene"</string>
    <string name="battery_tip_high_usage_title" product="default" msgid="1282187115295901930">"Telefon se upotrebljava više nego obično"</string>
    <string name="battery_tip_high_usage_title" product="tablet" msgid="7422137233845959351">"Tablet se upotrebljava više nego obično"</string>
    <string name="battery_tip_high_usage_title" product="device" msgid="5483320224273724068">"Uređaj se upotrebljava više nego obično"</string>
    <string name="battery_tip_high_usage_summary" msgid="6341311803303581798">"Baterija bi se uskoro mogla isprazniti"</string>
    <string name="battery_tip_dialog_message" product="default" msgid="7001932078713215338">"Vaš se telefon upotrebljavao više nego obično. Baterija bi se mogla isprazniti brže nego što očekujete.\n\nNajkorištenije aplikacije <xliff:g id="NUMBER">%1$d</xliff:g> od zadnjeg punjenja:"</string>
    <string name="battery_tip_dialog_message" product="tablet" msgid="8482296786233647690">"Vaš se tablet upotrebljavao više nego obično. Baterija bi se mogla isprazniti brže nego što očekujete.\n\nNajkorištenije aplikacije <xliff:g id="NUMBER">%1$d</xliff:g> od zadnjeg punjenja:"</string>
    <string name="battery_tip_dialog_message" product="device" msgid="2806861679225286129">"Vaš se uređaj upotrebljavao više nego obično. Baterija bi se mogla isprazniti brže nego što očekujete.\n\nNajkorištenije aplikacije <xliff:g id="NUMBER">%1$d</xliff:g> od zadnjeg punjenja:"</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 nedavno je ograničena</item>
      <item quantity="few">%2$d aplikacije nedavno su ograničene</item>
      <item quantity="other">%2$d aplikacija nedavno je ograničeno</item>
    </plurals>
    <plurals name="battery_tip_restrict_summary" formatted="false" msgid="5768962491638423979">
      <item quantity="one">%2$d aplikacija jako troši bateriju u pozadini</item>
      <item quantity="few">%2$d aplikacije jako troše bateriju u pozadini</item>
      <item quantity="other">%2$d aplikacija jako troši bateriju u pozadini</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="1040488674178753191">
      <item quantity="one">Ove se aplikacije ne mogu izvoditi u pozadini</item>
      <item quantity="few">Ove se aplikacije ne mogu izvoditi u pozadini</item>
      <item quantity="other">Ove se aplikacije ne mogu izvoditi u pozadini</item>
    </plurals>
    <plurals name="battery_tip_restrict_app_dialog_title" formatted="false" msgid="8130618585820429591">
      <item quantity="one">Želite li ograničiti %1$d aplikaciju?</item>
      <item quantity="few">Želite li ograničiti %1$d aplikacije?</item>
      <item quantity="other">Želite li ograničiti %1$d aplikacija?</item>
    </plurals>
    <string name="battery_tip_restrict_app_dialog_message" msgid="7271391929137806299">"Da biste uštedjeli bateriju, onemogućite da <xliff:g id="APP">%1$s</xliff:g> troši bateriju u pozadini. Ta aplikacija možda neće funkcionirati pravilno i obavijesti mogu kasniti."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="3175700359860699627">"Da biste uštedjeli bateriju, onemogućite da aplikacije navedene u nastavku troše bateriju u pozadini. Ograničene aplikacije možda neće funkcionirati pravilno i obavijesti mogu kasniti.\n\nAplikacije:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="582641081128076191">"Da biste uštedjeli bateriju, onemogućite da aplikacije navedene u nastavku troše bateriju u pozadini. Ograničene aplikacije možda neće funkcionirati pravilno i obavijesti mogu 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 li ukloniti ograničenje?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="6537761705584610231">"Ta će aplikacija moći upotrebljavati bateriju u pozadini. Baterija bi se mogla isprazniti brže 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 aplikacije budu prebrzo trošile bateriju, telefon će vam predložiti što biste mogli poduzeti.\n\nAko je razina baterije niska, možete uključiti Štednju baterije."</string>
    <string name="battery_tip_dialog_summary_message" product="tablet" msgid="8327950887399420971">"Vaše aplikacije troše bateriju uobičajenom brzinom. Ako aplikacije budu prebrzo trošile bateriju, tablet će vam predložiti što biste mogli poduzeti.\n\nAko je razina baterije niska, možete uključiti Štednju baterije."</string>
    <string name="battery_tip_dialog_summary_message" product="device" msgid="6753742263807939789">"Vaše aplikacije troše bateriju uobičajenom brzinom. Ako aplikacije budu prebrzo trošile bateriju, uređaj će vam predložiti što biste mogli poduzeti.\n\nAko je razina baterije niska, možete uključiti Štednju baterije."</string>
    <string name="smart_battery_manager_title" msgid="870632749556793417">"Battery Manager"</string>
    <string name="smart_battery_title" msgid="6218785691872466076">"Automatski upravljaj aplikacijama"</string>
    <string name="smart_battery_summary" msgid="1339184602000004058">"Ograničava potrošnju baterije za aplikacije koje ne upotrebljavate često"</string>
    <string name="smart_battery_footer" product="default" msgid="5555604955956219544">"Kada Battery Manager otkrije da aplikacije prazne bateriju, moći ćete ograničiti te aplikacije. Ograničene aplikacije možda neće funkcionirati pravilno i obavijesti mogu kasniti."</string>
    <string name="smart_battery_footer" product="tablet" msgid="5555604955956219544">"Kada Battery Manager otkrije da aplikacije prazne bateriju, moći ćete ograničiti te aplikacije. Ograničene aplikacije možda neće funkcionirati pravilno i obavijesti mogu kasniti."</string>
    <string name="smart_battery_footer" product="device" msgid="5555604955956219544">"Kada Battery Manager otkrije da aplikacije prazne bateriju, moći ćete ograničiti te aplikacije. Ograničene aplikacije možda neće funkcionirati pravilno i obavijesti mogu 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">"Te su aplikacije trošile bateriju u pozadini. Ograničene aplikacije možda neće funkcionirati pravilno i obavijesti mogu kasniti."</string>
    <string name="battery_auto_restriction_title" msgid="6553271897488963709">"Upotreba Battery Managera"</string>
    <string name="battery_auto_restriction_summary" msgid="8561335400991281062">"Otkriva kada aplikacije prazne bateriju"</string>
    <string name="battery_manager_on" msgid="8643310865054362396">"Uključeno/otkriva se kada aplikacije prazne 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="dialog_stop_title" msgid="6395127715596746479">"Zaustaviti aplikaciju?"</string>
    <string name="dialog_stop_message" product="default" msgid="4006631636646776488">"Vaš telefon ne može upravljati baterijom na uobičajen način jer ga aplikacija <xliff:g id="APP">%1$s</xliff:g> zadržava u aktivnom stanju.\n\nDa biste pokušali riješiti taj problem, možete zaustaviti tu aplikaciju.\n\nAko se problem ponovi, možda biste trebali deinstalirati tu aplikaciju da biste smanjili potrošnju baterije."</string>
    <string name="dialog_stop_message" product="tablet" msgid="2369957934555162428">"Vaš tablet ne može upravljati baterijom na uobičajen način jer ga aplikacija <xliff:g id="APP">%1$s</xliff:g> zadržava u aktivnom stanju.\n\nDa biste pokušali riješiti taj problem, možete zaustaviti tu aplikaciju.\n\nAko se problem ponovi, možda biste trebali deinstalirati tu aplikaciju da biste smanjili potrošnju baterije."</string>
    <string name="dialog_stop_message" product="device" msgid="6195430620406365292">"Vaš uređaj ne može upravljati baterijom na uobičajen način jer ga aplikacija <xliff:g id="APP">%1$s</xliff:g> zadržava u aktivnom stanju.\n\nDa biste pokušali riješiti taj problem, možete zaustaviti tu aplikaciju.\n\nAko se problem ponovi, možda biste trebali deinstalirati tu aplikaciju da biste smanjili potrošnju baterije."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="default" msgid="1638726742782558262">"Vaš telefon ne može upravljati baterijom na uobičajen način jer ga aplikacija <xliff:g id="APP_0">%1$s</xliff:g> neprestano aktivira.\n\nDa biste pokušali riješiti taj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g>.\n\nAko se problem ponovi, možda biste trebali deinstalirati tu aplikaciju da biste smanjili potrošnju baterije."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="tablet" msgid="8771690983566539742">"Vaš tablet ne može upravljati baterijom na uobičajen način jer ga aplikacija <xliff:g id="APP_0">%1$s</xliff:g> neprestano aktivira.\n\nDa biste pokušali riješiti taj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g>.\n\nAko se problem ponovi, možda biste trebali deinstalirati tu aplikaciju da biste smanjili potrošnju baterije."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="device" msgid="2854944538238649520">"Vaš uređaj ne može upravljati baterijom na uobičajen način jer ga aplikacija <xliff:g id="APP_0">%1$s</xliff:g> neprestano aktivira.\n\nDa biste pokušali riješiti taj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g>.\n\nAko se problem ponovi, možda biste trebali deinstalirati tu aplikaciju da biste smanjili potrošnju baterije."</string>
    <string name="dialog_stop_ok" msgid="2319777211264004900">"Zaustavi aplikaciju"</string>
    <string name="dialog_background_check_title" msgid="6936542136153283692">"Isključiti upotrebu u pozadini i zaustaviti aplikaciju?"</string>
    <string name="dialog_background_check_message" product="default" msgid="4045827746349279563">"Vaš telefon ne može upravljati baterijom na uobičajen način jer ga aplikacija <xliff:g id="APP_0">%1$s</xliff:g> neprestano aktivira.\n\nDa biste pokušali riješiti taj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g> i spriječiti njezino izvođenje u pozadini."</string>
    <string name="dialog_background_check_message" product="tablet" msgid="8348214419901788270">"Vaš tablet ne može upravljati baterijom na uobičajen način jer ga aplikacija <xliff:g id="APP_0">%1$s</xliff:g> neprestano aktivira.\n\nDa biste pokušali riješiti taj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g> i spriječiti njezino izvođenje u pozadini."</string>
    <string name="dialog_background_check_message" product="device" msgid="5847977433118915863">"Vaš uređaj ne može upravljati baterijom na uobičajen način jer ga aplikacija <xliff:g id="APP_0">%1$s</xliff:g> neprestano aktivira.\n\nDa biste pokušali riješiti taj problem, možete zaustaviti aplikaciju <xliff:g id="APP_1">%1$s</xliff:g> i spriječiti njezino izvođenje u pozadini."</string>
    <string name="dialog_background_check_ok" msgid="412876934682899659">"Isključi"</string>
    <string name="dialog_location_title" msgid="5888917530725874727">"Isključiti lokaciju?"</string>
    <string name="dialog_location_message" product="default" msgid="7774807745601479888">"Vaš telefon ne može upravljati baterijom na uobičajen način jer aplikacija <xliff:g id="APP">%1$s</xliff:g> neprestano zahtijeva vašu lokaciju kada je ne upotrebljavate.\n\nDa biste riješili taj problem, možete isključiti lokaciju za tu aplikaciju."</string>
    <string name="dialog_location_message" product="tablet" msgid="118745801732181618">"Vaš tablet ne može upravljati baterijom na uobičajen način jer aplikacija <xliff:g id="APP">%1$s</xliff:g> neprestano zahtijeva vašu lokaciju kada je ne upotrebljavate.\n\nDa biste riješili taj problem, možete isključiti lokaciju za tu aplikaciju."</string>
    <string name="dialog_location_message" product="device" msgid="6783678153382298295">"Vaš uređaj ne može upravljati baterijom na uobičajen način jer aplikacija <xliff:g id="APP">%1$s</xliff:g> neprestano zahtijeva vašu lokaciju kada je ne upotrebljavate.\n\nDa biste riješili taj problem, možete isključiti lokaciju za tu aplikaciju."</string>
    <string name="dialog_location_ok" msgid="4572391197601313986">"Isključi"</string>
    <string name="power_screen" msgid="3023346080675904613">"Zaslon"</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">"Tabletni uređaj u mirovanju"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Telefon u mirovanju"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Razno"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Previše obračunato"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"Ukupno CPU-a"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"Glavni zadatak CPU-a"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Zadrži u aktivnom stanju"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Wi-Fi se izvodi"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tabletni uređaj"</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 je radio aktivan"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Poslani Wi‑Fi paketi"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Primljeni Wi‑Fi paketi"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Audio"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Videozapis"</string>
    <string name="usage_type_camera" msgid="8299433109956769757">"Fotoaparat"</string>
    <string name="usage_type_flashlight" msgid="1516392356962208230">"Bljeskalica"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Vrijeme uključenosti"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Vrijeme bez signala"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Ukupan kapacitet baterije"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Obračunata potrošnja energije"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Izmjerena potrošnja energije"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Prisilno zaustavi"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Info o aplikaciji"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Postavke aplikacije"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Postavke zaslona"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Postavke Wi-Fi-ja"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Bluetooth postavke"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Baterija upotrijebljena uslugom glasovnog poziva"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Upotreba baterije kad je tabletni uređaj u mirovanju"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Upotreba baterije tijekom mirovanja telefona"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Baterija iskorištena upotrebom radija"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Prebacite se na način rada u zrakoplovu u područjima loše pokrivenosti signalom da biste uštedjeli energiju"</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Potrošnja baterije za svjetiljku"</string>
    <string name="battery_desc_camera" msgid="7375389919760613499">"Potrošnja baterije za fotoaparat"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Baterija se koristi za prikaz i pozadinsko svjetlo"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Smanjite svjetlinu i/ili vrijeme čekanja zaslona"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Baterijom se služi Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="7776093125855397043">"Isključi Wi-Fi ako se ne upotrebljava ili ako nije dostupan"</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Baterija iskorištena upotrebom značajke Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="4565141162650835009">"Isključite Bluetooth ako ga ne upotrebljavate"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Pokušajte se povezati s drugim Bluetooth uređajem"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Baterija iskorištena upotrebom aplikacija"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Zaustavite ili deinstalirajte aplikaciju"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Odaberite način štednje baterije"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Aplikacija možda nudi postavke za smanjenje potrošnje baterije"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Baterija koju upotrebljava korisnik"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Potrošnja energije u razne svrhe"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"Upotreba baterije procjena je potrošnje energije i ne uključuje sve izvore potrošnje baterije. Vrijednost \"razno\" odnosi se na razliku između obračunate procijenjene potrošnje energije i stvarne potrošnje izmjerene na bateriji."</string>
    <string name="battery_desc_overcounted" msgid="5481865509489228603">"Previše obračunata potrošnja energije"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="2690821851327075443">"Upotrebljava se <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="2964359540508103032">"Aktivno <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="6537658662149713585">"Upotreba zaslona <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="1135316757755282999">"<xliff:g id="APP">%2$s</xliff:g> upotrebljava <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 potrošnje baterije"</string>
    <string name="battery_detail_since_full_charge" msgid="7515347842046955855">"Razrada od posljednjeg potpunog punjenja"</string>
    <string name="battery_last_full_charge" msgid="7151251641099019361">"Posljednje potpuno punjenje"</string>
    <string name="battery_full_charge_last" msgid="8892335687734288031">"Potpuna napunjenost traje oko"</string>
    <string name="battery_footer_summary" msgid="67169726550144016">"Podaci o upotrebi približni su i mogu se promijeniti ovisno o upotrebi"</string>
    <string name="battery_detail_foreground" msgid="3350401514602032183">"Dok je u aktivnoj upotrebi"</string>
    <string name="battery_detail_background" msgid="1929644393553768999">"Dok radi u pozadini"</string>
    <string name="battery_detail_power_usage" msgid="6485766868610469101">"Potrošnja baterije"</string>
    <string name="battery_detail_info_title" msgid="8227822131405620369">"Od potpunog punjenja"</string>
    <string name="battery_detail_manage_title" msgid="9094314252105828014">"Upravljanje potrošnjom baterije"</string>
    <string name="advanced_battery_graph_subtext" msgid="5621073891377915877">"Procjena stanja baterije temelji se na upotrebi uređaja"</string>
    <string name="estimated_time_left" msgid="7514194472683370877">"Procijenjeno preostalo vrijeme"</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 ovisno o upotrebi"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> od isključivanja"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Kod posljednjeg isključivanja za <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Ukupno iskoriš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">"Medijski poslužitelj"</string>
    <string name="process_dex2oat_label" msgid="2592408651060518226">"Optimizacija aplikacija"</string>
    <string name="battery_saver" msgid="8172485772238572153">"Štednja baterije"</string>
    <string name="battery_saver_auto_title" msgid="8368709389419695611">"Uključi automatski"</string>
    <string name="battery_saver_seekbar_title" msgid="4705356758573183963">"Na <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_seekbar_title_placeholder" msgid="1138980155985636295">"Uključi"</string>
    <string name="battery_saver_master_switch_title" msgid="622539414546588436">"Upotreba Štednje baterije"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Uključi automatski"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Nikada"</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 baterije"</string>
    <string name="battery_percentage_description" msgid="8511658577507384014">"Prikaži postotak baterije na traci statusa"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Statistički podaci o procesima"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Detaljni statistički podaci o trenutačnim procesima"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Upotreba memorije"</string>
    <string name="process_stats_total_duration" msgid="7417201400853728029">"Iskorišteno <xliff:g id="USEDRAM">%1$s</xliff:g> od <xliff:g id="TOTALRAM">%2$s</xliff:g> tijekom <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="6522457033380025618">"Iskorišteno <xliff:g id="PERCENT">%1$s</xliff:g> RAM-a tijekom <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">"Prednji plan"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"Spremljeno u privremenu memoriju"</string>
    <string name="process_stats_os_label" msgid="4813434110442733392">"OS Android"</string>
    <string name="process_stats_os_native" msgid="5322428494231768472">"Nativni procesi"</string>
    <string name="process_stats_os_kernel" msgid="1938523592369780924">"Jezgra sustava"</string>
    <string name="process_stats_os_zram" msgid="677138324651671575">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="6432533624875078233">"Predmemorije"</string>
    <string name="process_stats_ram_use" msgid="976912589127397307">"Iskorištenost RAM-a"</string>
    <string name="process_stats_bg_ram_use" msgid="5398191511030462404">"Iskorištenost RAM-a (u pozadini)"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Vrijeme izvođenja"</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">"Informacije 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 sustav"</string>
    <string name="menu_hide_system" msgid="4106826741703745733">"Sakrij sustav"</string>
    <string name="menu_show_percentage" msgid="4717204046118199806">"Prikaži postotke"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Upotrijebi USS"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Vrsta statističkih podataka"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"Pozadina"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"Prednji plan"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"Spremljeno u privremenu memoriju"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Glas. ulaz i izlaz"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Postavke za glasovni unos i izlazne vrijednosti"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Glasovno pretraživanje"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Android tipkovnica"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Postavke glasovnog unosa"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Glasovni unos"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Usluge glasovnog unosa"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Potpuni pokretač značajki 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">"Usluga glasovnog unosa moći će u vaše ime neprekidno nadzirati glasovne unose i kontrolirati aplikacije s omogućenom glasovnom interakcijom. Pruža je <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Želite li omogućiti tu uslugu?"</string>
    <string name="tts_engine_preference_title" msgid="1578826947311494239">"Željeni alat"</string>
    <string name="tts_engine_settings_title" msgid="6886964122861384818">"Postavke alata"</string>
    <string name="tts_sliders_title" msgid="992059150784095263">"Brzina govora i visina glasa"</string>
    <string name="tts_engine_section_title" msgid="6289240207677024034">"Alat"</string>
    <string name="tts_install_voice_title" msgid="6275828614052514320">"Glasovi"</string>
    <string name="tts_spoken_language" msgid="5542499183472504027">"Govorni jezik"</string>
    <string name="tts_install_voices_title" msgid="8808823756936022641">"Instaliranje glasova"</string>
    <string name="tts_install_voices_text" msgid="5292606786380069134">"Nastavite u aplikaciju <xliff:g id="TTS_APP_NAME">%s</xliff:g> da biste instalirali glasove"</string>
    <string name="tts_install_voices_open" msgid="667467793360277465">"Otvori aplikaciju"</string>
    <string name="tts_install_voices_cancel" msgid="4711492804851107459">"Odustani"</string>
    <string name="tts_reset" msgid="2661752909256313270">"Vrati na zadano"</string>
    <string name="tts_play" msgid="2628469503798633884">"Reproduciraj"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Pohrana vjerodajnica"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Instaliraj iz memorije"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Instaliraj s SD kartice"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Instaliraj certifikate iz memorije"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Instaliraj certifikate s SD kartice"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Izbriši vjerodajnice"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Uklanjanje svih certifikata"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Pouzdane vjerodajnice"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Prikaz pouzdanih CA certifikata"</string>
    <string name="user_credentials" msgid="3719013347787187083">"Korisničke vjerodajnice"</string>
    <string name="user_credentials_summary" msgid="7271228342106080167">"Prikaz i izmjena pohranjenih vjerodajnica"</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">"Hardverska"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Samo softverska"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Za ovog korisnika nisu dostupne vjerodajnice"</string>
    <string name="credential_for_vpn_and_apps" msgid="4168197158768443365">"Instalirano za VPN i aplikacije"</string>
    <string name="credential_for_wifi" msgid="6228425986551591864">"Instalirano za Wi-Fi"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Ukloniti sve sadržaje?"</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Pohrana vjerodajnica izbrisana je."</string>
    <string name="credentials_not_erased" msgid="7685932772284216097">"Pohrana vjer. nije izbrisana."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="8058230497337529036">"Prije nego što možete koristiti pohranu vjerodajnica, vaš uređaj mora imati siguran zaključan zaslon"</string>
    <string name="credentials_configure_lock_screen_button" msgid="253239765216055321">"POSTAVI ZAKLJUČAV."</string>
    <string name="usage_access_title" msgid="332333405495457839">"Apl. s pristupom pod. o upot."</string>
    <string name="emergency_tone_title" msgid="254495218194925271">"Signal za hitne pozive"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Postavite način ponašanja za hitni poziv"</string>
    <string name="privacy_settings_title" msgid="2978878794187459190">"Sigurnosna 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">"Osobni podaci"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Sigurnosno kopiranje"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Stvaranje sigurnosne kopije podataka aplikacije, Wi-Fi zaporki i ostalih postavki na Googleovim poslužiteljima"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Sigurnosni račun"</string>
    <string name="backup_data_management_title" msgid="4059093462647090064">"Upravljanje računom za sigurnosno kopiranje"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Uključi podatke aplikacija"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Automatska obnova"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Pri ponovnoj instalaciji aplikacije vratiti postavke i podatke za koje su stvorene sigurnosne kopije"</string>
    <string name="backup_inactive_title" msgid="685838037986644604">"Usluga sigurnosnog kopiranja nije aktivna"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Nijedan račun trenutno ne stvara sigurnosne kopije podataka"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Želite li zaustaviti stvaranje sigurnosnih kopija Wi-Fi zaporki, oznaka, drugih postavki i podataka aplikacija te izbrisati sve kopije na Googleovim poslužiteljima?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="694766389396659626">"Želite li zaustaviti sigurnosno kopiranje podatka s uređaja (kao što su zaporke za Wi-Fi i povijest poziva) i podataka aplikacija (kao što su postavke i datoteke koje aplikacije spremaju) te izbrisati sve kopije na udaljenim poslužiteljima?"</string>
    <string name="fullbackup_data_summary" msgid="960850365007767734">"Daljinski pokrenite automatsku izradu sigurnosne kopije podataka uređaja (kao što su zaporke Wi-Fi-ja i povijest poziva) i podataka aplikacija (kao što su postavke i datoteke koje aplikacije pohranjuju).\n\nKada uključite automatsku izradu sigurnosnih kopija, podaci uređaja i aplikacija periodično se daljinski spremaju. Podaci aplikacije mogu biti bilo koji podaci koje je aplikacija spremila (na temelju postavki razvojnog programera), uključujuć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 aplikaciju administratora ovog 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">"Osobno"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Posao"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Pouzdani predstavnici nisu dostupni"</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 ovog uređaja"</string>
    <string name="device_admin_add_title" msgid="3140663753671809044">"Administrator uređaja"</string>
    <string name="device_admin_warning" msgid="7482834776510188134">"Aktiviranjem ove administratorske aplikacije dopustit ćete aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> da izvede sljedeće postupke:"</string>
    <string name="device_admin_status" msgid="7234814785374977990">"Ova je administratorska aplikacija aktivna i omogućuje aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> izvođenje sljedećih postupaka:"</string>
    <string name="profile_owner_add_title" msgid="6249331160676175009">"Želite li aktivirati upravitelj profila?"</string>
    <string name="adding_profile_owner_warning" msgid="1354474524852805802">"Ako nastavite, vašim će korisnikom upravljati administrator, koji uz vaše osobne podatke može spremiti i povezane podatke.\n\nVaš administrator može nadzirati postavke, pristup, aplikacije i podatke povezane s tim korisnikom, uključujući aktivnosti na mreži i podatke o lokaciji uređaja te njima upravljati."</string>
    <string name="admin_disabled_other_options" msgid="7712694507069054530">"Ostale je opcije onemogućio vaš administrator"</string>
    <string name="admin_more_details" msgid="7901420667346456102">"Više pojedinosti"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Općenito"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Zapisnik obavijesti"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Melodija zvona i vibriranje za poziv"</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"Sustav"</string>
    <string name="wifi_setup_title" msgid="2970260757780025029">"Postavljanje Wi-Fi mreže"</string>
    <string name="wifi_setup_title_editing_network" msgid="6020614644556717979">"Povezivanje s Wi-Fi mrežom <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_connecting_network" msgid="5572226790101017822">"Povezivanje s Wi-Fi mrežom <xliff:g id="NETWORK_NAME">%s</xliff:g>…"</string>
    <string name="wifi_setup_title_connected_network" msgid="1608788657122010919">"Povezano s Wi-Fi mrežom <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Dodavanje mreže"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Nije povezan"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Dodaj mrežu"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Osvježi popis"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Preskoči"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"Dalje"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Natrag"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Detalji mreže"</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Poveži"</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Zaboravi"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Spremi"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Odustani"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Skeniranje mreža…"</string>
    <string name="wifi_setup_status_select_network" msgid="3960480613544747397">"Dodirnite mrežu da biste se povezali s njom"</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Spoji s postojećom mrežom"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Pov. s nesigurnom mrežom"</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Upišite konfiguraciju mreže"</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Spoji s novom mrežom"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Povezivanje…"</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Idite na sljedeći korak"</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="6796317704783144190">"EAP nije podržan."</string>
    <string name="wifi_setup_eap_not_supported" msgid="6812710317883658843">"Ne možete konfigurirati EAP Wi-Fi vezu tijekom postavljanja. To možete učiniti nakon postavljanja u Postavkama pod stavkom Bežično povezivanje i mreže."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"Povezivanje može potrajati nekoliko minuta..."</string>
    <string name="wifi_setup_description_connected" msgid="6649168170073219153">"Dodirnite "<b>"Dalje"</b>" da biste nastavili s postavljanjem.\n\nDodirnite "<b>"Natrag"</b>" da biste se povezali s nekom drugom Wi‑Fi mrežom."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Sinkronizacija je omogućena"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Onemogućena je sinkronizacija"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Sinkronizacija u tijeku"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Pogreška sinkronizacije"</string>
    <string name="sync_failed" msgid="1696499856374109647">"Sinkronizacija nije uspjela"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sinkronizacija aktivna"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sinkronizacija"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Sinkronizacija trenutačno ima problema. Uskoro će nastaviti s radom."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Dodavanje računa"</string>
    <string name="managed_profile_not_available_label" msgid="852263300911325904">"Radni profil još nije dostupan"</string>
    <string name="work_mode_label" msgid="7157582467956920750">"Radni profil"</string>
    <string name="work_mode_on_summary" msgid="3628349169847990263">"Pod upravljanjem vaše organizacije"</string>
    <string name="work_mode_off_summary" msgid="2657138190560082508">"Isključene su aplikacije i obavijesti"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Ukloni radni profil"</string>
    <string name="background_data" msgid="5779592891375473817">"Pozadinski podaci"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Aplikacije mogu sink., slati i primati podatke bilo kad"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Onem. poz. podatke?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Onemogućavanje pozadinskih podataka produljuje trajanje baterije i smanjuje upotrebu podataka. Neke aplikacije još uvijek mogu upotrebljavati pozadinsku podatkovnu vezu."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Automat. sink. podataka aplikacije"</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Sink. uključena"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Sink. ISKLJUČENA"</string>
    <string name="sync_error" msgid="5060969083117872149">"Pogreška sink."</string>
    <string name="last_synced" msgid="4242919465367022234">"Zadnja sinkronizacija: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Sinkronizacija u tijeku…"</string>
    <string name="settings_backup" msgid="2274732978260797031">"Postavke sigurnosne kopije"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Stvori sigurnosnu kopiju postavki"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Sinkroniziraj sada"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Otkaži sinkronizaciju"</string>
    <string name="sync_one_time_sync" msgid="3733796114909082260">"Dodirnite da biste sinkronizirali 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 Googleovu sinkronizaciju!"</font>\n"Googleov pristup sinkronizaciji podataka za mogućnost pristupa kontaktima, sastancima i drugim stavkama s bilo kojeg mjesta."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Postavke sinkronizacije aplikacije"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Podaci i sinkronizacija"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Promijeni zaporku"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Postavke računa"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Izbriši račun"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Dodavanje računa"</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 izbrisat će se sve njegove poruke, kontakti i ostali podaci s tabletnog računala!"</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Uklanjanjem ovog računa izbrisat će se sve njegove poruke, kontakti i ostali podaci s telefona!"</string>
    <string name="really_remove_account_message" product="device" msgid="7507474724882080166">"Ako uklonite taj račun, s uređaja će se izbrisati sve njegove poruke, kontakti i ostali podaci!"</string>
    <string name="remove_account_failed" msgid="3901397272647112455">"Vaš administrator ne dopušta tu promjenu"</string>
    <string name="cant_sync_dialog_title" msgid="2777238588398046285">"Nije moguća ručna sinkronizacija"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Sinkronizacija za tu stavku trenutačno je onemogućena. Da biste promijenili tu postavku, privremeno uključite pozadinske podatke i automatsku sinkronizaciju."</string>
    <string name="enter_password" msgid="8035706727471334122">"Da biste pokrenuli Android, unesite zaporku"</string>
    <string name="enter_pin" msgid="5305333588093263790">"Da biste pokrenuli Android, unesite svoj 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 uzorak"</string>
    <string name="cryptkeeper_wrong_password" msgid="5200857195368904047">"Pogrešna zaporka"</string>
    <string name="cryptkeeper_wrong_pin" msgid="755720788765259382">"Pogrešan PIN"</string>
    <string name="checking_decryption" msgid="8287458611802609493">"Provjeravanje…"</string>
    <string name="starting_android" msgid="4001324195902252681">"Pokretanje Androida..."</string>
    <string name="delete" msgid="4219243412325163003">"Izbriši"</string>
    <string name="misc_files" msgid="6720680815969643497">"Razne datoteke"</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">"Odaberi sve"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Podatkovni promet"</string>
    <string name="data_usage_app_summary_title" msgid="5571051159374290375">"Mobilni podaci i Wi‑Fi"</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"Mobilni operater može obračunavati podatke na drugačiji način od uređaja."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Potrošnja aplikacije"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"INFORMACIJE O APLIKACIJAMA"</string>
    <string name="data_usage_cellular_data" msgid="9168928285122125137">"Mobilni podaci"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Postavljanje ograničenja potrošnje"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Ciklus upotrebe podataka"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Potrošnja aplikacije"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Roaming podataka"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Ograničenje pozadinskih podataka"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Dopusti pozadinske podatke"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Zasebna upotreba mreže 4G"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Pokaži Wi-Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Sakrij Wi-Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Prikaži Ethernet upotrebu"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Sakrij upotrebu etherneta"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Mrežna ograničenja"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Automatska sinkronizacija podataka"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"SIM kartice"</string>
    <string name="data_usage_cellular_data_summary" msgid="8413357481361268285">"Zaustavljeno na granici"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Automat. sinkroniziraj podatke"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Aut. sinkroniz. osobne podatke"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Aut. sinkroniz. radne podatke"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Promjena ciklusa..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Dan u mjesecu za poništavanje ciklusa upotrebe podataka:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"U tom razdoblju aplik. nisu upotreblj. podatke."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Prednji 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 mobilne podatke?"</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"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Postavi ograničenje za 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Ograniči podatke za Wi-Fi"</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">"Mobilno"</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">"Ništa"</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">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Prednji 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ći upotrebu mobilnih podataka 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čenje pozadinskih podataka?"</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 pozadinskih podataka moguće je samo ako ste postavili ograničenje mobilnog podatkovnog prometa."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Uključiti auto. sinkronizaciju?"</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 taj 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 taj način."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Isključiti auto. sinkronizaciju?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4025938250775413864">"Time će se uštedjeti na podatkovnom prometu i smanjiti potrošnja baterije, ali svaki ćete račun morati ručno sinkronizirati kako biste dobili najnovije informacije. Nećete primati obavijesti o ažuriranjima."</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 u mjesecu:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Postavi"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Postavite upozorenje o potrošnji podataka"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Postavite ograničenje podatkovnog prometa"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Ograničenje podatkovnog prometa"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="4983487893343645667">"Tablet će isključiti mobilne podatke kada dosegne ograničenje koje ste postavili.\n\nBudući da potrošnju podataka mjeri tablet i da se obračun mobilnog operatera može razlikovati, možda biste trebali postaviti strože ograničenje."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3926320594049434225">"Telefon će isključiti mobilne podatke kada dosegne ograničenje koje ste postavili.\n\nBudući da potrošnju podataka mjeri telefon i da se obračun mobilnog operatera može razlikovati, možda biste trebali postaviti strože ograničenje."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Ograničenje pozadinskih podataka?"</string>
    <string name="data_usage_restrict_background" msgid="434093644726734586">"Ako ograničite pozadinske mobilne podatke, neke aplikacije i usluge funkcionirat će samo ako se povežete s Wi‑Fi mrežom."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="7096707497743363380">"Ako ograničite pozadinske mobilne podatke, neke aplikacije i usluge funkcionirat će samo ako se povežete s Wi‑Fi mrežom.\n\nTa postavka utječe na sve korisnike tableta."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="7910798414964288424">"Ako ograničite pozadinske mobilne podatke, neke aplikacije i usluge funkcionirat će samo ako se povežete s Wi‑Fi mrežom.\n\nTa postavka utječe na sve korisnike telefona."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="12">"Upozori na"</font>\n<font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</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>: upotrijebljeno 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>: upotrijebljeno oko <xliff:g id="TOTAL">%1$s</xliff:g>, prema mjerenju tableta. Operater može mjeriti drukčije."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="5063981061103812900">"<xliff:g id="RANGE">%2$s</xliff:g>: upotrijebljeno oko <xliff:g id="TOTAL">%1$s</xliff:g>, prema mjerenju telefona. Operater može mjeriti drukčije."</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 su pozadinski podaci ograničeni. Aplikacije mogu dati upozorenje prije upotrebe tih 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">"Wi-Fi mreže s naplatom"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Da biste odabrali mreže s naplatom, uključite Wi‑Fi."</string>
    <string name="data_usage_metered_auto" msgid="1262028400911918865">"Automatski"</string>
    <string name="data_usage_metered_yes" msgid="9217539611385225894">"S naplatom prijenosa"</string>
    <string name="data_usage_metered_no" msgid="4025232961929071789">"Bez naplate prijenosa"</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Mobilni operater može obračunavati podatke na drugačiji način od uređaja."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Hitni poziv"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Vrati se na poziv"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Naziv"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Vrsta"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Adresa poslužitelja"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"PPP enkripcija (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"tajna L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"IPSec identifikator"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"IPSec unaprijed dijeljeni 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 poslužitelja"</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 poslužitelji (npr. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Prosljeđivanje ruta (npr. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Korisničko ime"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Zaporka"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Spremi podatke o računu"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(ne koristi se)"</string>
    <string name="vpn_no_ca_cert" msgid="8776029412793353361">"(ne potvrđuj poslužitelj)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(primljen od poslužitelja)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="7574518311224455825">"Ova vrsta VPN-a ne može ostati povezana u svakom trenutku"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="477304620899799383">"Uvijek uključeni VPN podržava samo numeričke adrese poslužitelja"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="2226648961940273294">"Za uvijek uključeni VPN mora biti naveden DNS poslužitelj"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3551394495620249972">"Adrese DNS poslužitelja za uvijek uključeni VPN moraju biti numeričke"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="5959352052515258208">"Uneseni podaci ne podržavaju uvijek uključeni VPN"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Odustani"</string>
    <string name="vpn_done" msgid="8678655203910995914">"Odbaci"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Spremi"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Poveži"</string>
    <string name="vpn_replace" msgid="5442836256121957861">"Zamijeni"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Uređivanje VPN profila"</string>
    <string name="vpn_forget" msgid="3684651372749415446">"Zaboravi"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Povezivanje s profilom <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="3743970132487505659">"Prekinuti vezu s 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 dosadašnji VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="4009987321156037267">"Želite li postaviti uvijek uključeni VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="7144543717673197102">"Kada je ta postavka uključena, nećete imati internetsku vezu dok se VPN ne poveže"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="798121133114824006">"Vaš dosadašnji VPN zamijenit će se 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 s uvijek uključenim VPN-om. Ako se povežete s nekim drugim VPN-om, on će zamijeniti dosadašnji, a način rada \"uvijek uključeno\" isključit će se."</string>
    <string name="vpn_replace_vpn_message" msgid="5611635724578812860">"Već ste povezani s VPN-om. Ako se povežete s nekim drugi VPN-om, on će zamijeniti dosadašnji."</string>
    <string name="vpn_turn_on" msgid="2363136869284273872">"Uključi"</string>
    <string name="vpn_cant_connect_title" msgid="4517706987875907511">"Povezivanje s <xliff:g id="VPN_NAME">%1$s</xliff:g> mrežom nije uspjelo"</string>
    <string name="vpn_cant_connect_message" msgid="1352832123114214283">"Ova aplikacija ne podržava uvijek uključeni VPN"</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Dodavanje VPN profila"</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 uključena VPN mreža"</string>
    <string name="vpn_no_vpns_added" msgid="5002741367858707244">"Nije dodan nijedan VPN"</string>
    <string name="vpn_always_on_summary" msgid="2821344524094363617">"Zadrži vezu s VPN-om u svakom trenutku"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="592304911378771510">"Ova aplikacija ne podržava tu opciju"</string>
    <string name="vpn_always_on_summary_active" msgid="8800736191241875669">"Značajka Uvijek uključeno aktivna"</string>
    <string name="vpn_require_connection" msgid="8388183166574269666">"Blokiraj veze bez VPN-a"</string>
    <string name="vpn_require_connection_title" msgid="159053539340576331">"Zahtijevati VPN vezu?"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Odaberite VPN profil s kojim ćete uvijek biti povezani. Mrežni promet bit će dopušten samo kada ste povezani s tom VPN mrežom."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Ništa"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Uvijek uključena VPN mreža zahtijeva IP adresu za poslužitelj 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">"Prekinuta veza s VPN-om"</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">"Sustav"</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">"Smatraj pouzdanim"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Želite li omogućiti sistemski CA certifikat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Želite li onemogućiti sistemski CA certifikat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Želite li 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">"Pojedinosti o vjerodajnicama"</string>
    <string name="user_credential_removed" msgid="6514189495799401838">"Uklonjena vjerodajnica: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="3729607560420971841">"Nema instaliranih korisničkih vjerodajnica"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Provjera pravopisa"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Ovdje unesite trenutačnu zaporku za potpunu sigurnosnu kopiju"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Ovdje upišite novu zaporku za potpunu sigurnosnu kopiju"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Ovdje ponovo unesite novu zaporku za potpunu sigurnosnu kopiju"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Postavi zaporku za sigurnosnu kopiju"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Odustani"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Dodatna ažuriranja sustava"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Mreža se možda nadzire"</string>
    <string name="done_button" msgid="1991471253042622230">"Završeno"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="7145092748045794650">
      <item quantity="one">Označite certifikate kao pouzdane ili ih uklonite</item>
      <item quantity="few">Označite certifikate kao pouzdane ili ih uklonite</item>
      <item quantity="other">Označite certifikate kao pouzdane 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> instalirala je izdavače certifikata na vaš uređaj, što joj može omogućiti nadzor nad mrežnim aktivnostima uređaja, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o certifikatima možete saznati od administratora.</item>
      <item quantity="few">Domena <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> instalirala je izdavače certifikata na vaš uređaj, što joj može omogućiti nadzor nad mrežnim aktivnostima uređaja, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o certifikatima možete saznati od administratora.</item>
      <item quantity="other">Domena <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> instalirala je izdavače certifikata na vaš uređaj, što joj može omogućiti nadzor nad mrežnim aktivnostima uređaja, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o certifikatima možete saznati od administratora.</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> instalirala je izdavače certifikata za vaš radni profil, što joj može omogućiti nadzor nad aktivnostima radne mreže, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o certifikatima možete saznati od administratora.</item>
      <item quantity="few">Domena <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> instalirala je izdavače certifikata za vaš radni profil, što joj može omogućiti nadzor nad aktivnostima radne mreže, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o certifikatima možete saznati od administratora.</item>
      <item quantity="other">Domena <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> instalirala je izdavače certifikata za vaš radni profil, što joj može omogućiti nadzor nad aktivnostima radne mreže, uključujući e-poruke, aplikacije i zaštićene web-lokacije.\n\nViše informacija o certifikatima možete saznati od administratora.</item>
    </plurals>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"Treća je strana u mogućnosti pratiti vašu mrežnu aktivnost, uključujući e-poštu, aplikacije i sigurne web-lokacije.\n\nTo omogućuje pouzdana vjerodajnica koja je instalirana na vašem uređaju."</string>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="2426799352517325228">
      <item quantity="one">Provjeri certifikate</item>
      <item quantity="few">Provjeri certifikate</item>
      <item quantity="other">Provjeri certifikate</item>
    </plurals>
    <string name="user_settings_title" msgid="3493908927709169019">"Više korisnika"</string>
    <string name="user_settings_footer_text" product="device" msgid="5947601460660791129">"Da biste dijelili uređaj, dodajte nove korisnike. Svaki korisnik ima osobni prostor na vašem uređaju za prilagođene početne zaslone, račune, aplikacije, postavke i drugo."</string>
    <string name="user_settings_footer_text" product="tablet" msgid="2153761434649733502">"Da biste dijelili tablet, dodajte nove korisnike. Svaki korisnik ima osobni prostor na vašem tabletu za prilagođene početne zaslone, račune, aplikacije, postavke i drugo."</string>
    <string name="user_settings_footer_text" product="default" msgid="2844602828189838075">"Da biste dijelili telefon, dodajte nove korisnike. Svaki korisnik ima osobni prostor na vašem telefonu za prilagođene početne zaslone, račune, aplikacije, postavke i drugo."</string>
    <string name="user_list_title" msgid="7937158411137563543">"Korisnici i profili"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Dodavanje korisnika ili profila"</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 izrade ograničenog profila trebate postaviti zaključavanje zaslona radi zaštite svojih aplikacija i osobnih podataka."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Postavi zaključavanje"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Nije postavljen"</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">"Dodavanje"</string>
    <string name="user_add_max_count" msgid="5405885348463433157">"Ne možete dodati više od <xliff:g id="USER_COUNT">%1$d</xliff:g> korisnika"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Korisnici imaju vlastite aplikacije i sadržaj"</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Možete ograničiti pristup aplikacijama i sadržaju sa svojeg 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">"Da biste ovaj uređaj dijelili s drugima, možete napraviti dodatne korisnike. Svaki korisnik ima svoj prostor koji može prilagoditi pomoću vlastitih aplikacija, pozadine i tako dalje. Korisnici mogu prilagoditi i postavke uređaja koje utječu na sve ostale korisnike, na primjer Wi‑Fi.\n\nKada dodate novog korisnika, ta osoba mora postaviti svoj prostor.\n\nBilo koji korisnik može ažurirati aplikacije za sve ostale korisnike. Postavke i usluge pristupačnosti možda se neće prenijeti na novog korisnika."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Kada dodate novog korisnika, ta osoba mora postaviti vlastiti prostor.\n\nBilo koji 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">"Želite li sada postaviti profil?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Postavi sada"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Ne sad"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="7153048188252553320">"Samo vlasnik tabletnog računala 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 dodavati račune"</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"<xliff:g id="USER_NAME">%1$s</xliff:g>: brisanje s uređaja"</string>
    <string name="user_lockscreen_settings" msgid="4965661345247084878">"Postavke zaključavanja zaslona"</string>
    <string name="user_add_on_lockscreen_menu" msgid="9072312646546364619">"Dodavanje korisnika sa zaključanog zaslona"</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">"Izbrisati sebe?"</string>
    <string name="user_confirm_remove_title" msgid="1163721647646152032">"Ukloniti korisnika?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Ukloniti profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"Ukloniti radni profil?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="2391372805233812410">"Izgubit ćete svoj prostor i podatke na ovom tabletnom računalu. Ta se radnja ne može poništiti."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="7943645442479360048">"Izgubit ćete svoj prostor i podatke na ovom telefonu. Ta se radnja ne može poništiti."</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"Izbrisat će se sve aplikacije i podaci."</string>
    <string name="work_profile_confirm_remove_message" msgid="323856589749078140">"Ako nastavite, izbrisat će se sve aplikacije i podaci na profilu."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"Izbrisat će se sve aplikacije i podaci."</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">"Uklanjanje 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 u ovoj sesiji bit će izbrisani."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Ukloni"</string>
    <string name="user_enable_calling" msgid="5128605672081602348">"Uključivanje telefonskih poziva"</string>
    <string name="user_enable_calling_sms" msgid="9172507088023097063">"Uključivanje telefonskih poziva i SMS-a"</string>
    <string name="user_remove_user" msgid="6490483480937295389">"Ukloni korisnika"</string>
    <string name="user_enable_calling_confirm_title" msgid="4315789475268695378">"Želite li uključiti telefonske pozive?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"Povijest poziva dijelit će se s tim korisnikom."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="7243308401401932681">"Želite li uključiti telefonske pozive i SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="4025082715546544967">"Povijest poziva i SMS-ova dijelit će se s tim korisnikom."</string>
    <string name="emergency_info_title" msgid="208607506217060337">"Informacije u hitnom slučaju"</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">"Dopuštanje aplikacija i sadržaja"</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 rada"</string>
    <string name="nfc_payment_no_apps" msgid="5477904979148086424">"Plaćajte telefonom u trgovinama"</string>
    <string name="nfc_payment_default" msgid="8648420259219150395">"Zadano 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">"Koristi zadano"</string>
    <string name="nfc_payment_favor_default" msgid="5743781166099608372">"Uvijek"</string>
    <string name="nfc_payment_favor_open" msgid="1923314062109977944">"Osim kada je otvorena neka druga aplikacija za plaćanje"</string>
    <string name="nfc_payment_pay_with" msgid="7524904024378144072">"Na terminalu \"Dodirni i plati\" plati na sljedeći način:"</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 samo prislonite stražnju stranu telefona na bilo koji terminal sa simbolom beskontaktnog povezivanja."</string>
    <string name="nfc_how_it_works_got_it" msgid="259653300203217402">"Shvaćam"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Više..."</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Želite li to postaviti kao željeni način?"</string>
    <string name="nfc_payment_set_default" msgid="8532426406310833489">"Želite li uvijek upotrebljavati aplikaciju <xliff:g id="APP">%1$s</xliff:g> za plaćanje na način \"Dodirni i plati\"?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="6993301165940432743">"Želite li uvijek upotrebljavati aplikaciju <xliff:g id="APP_0">%1$s</xliff:g> umjesto aplikacije <xliff:g id="APP_1">%2$s</xliff:g> prilikom plaćanja na način \"Dodirni i plati\"?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Ograničenja"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Uklanjanje ograničenja"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Promjena PIN-a"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Prikaži obavijesti"</string>
    <string name="help_label" msgid="6886837949306318591">"Pomoć/povratne inf."</string>
    <string name="support_summary" msgid="2705726826263742491">"Članci pomoći, telefoniranje 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">"Primanje upozorenja za ekstremne prijetnje po život/imovinu"</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Ozbiljne prijetnje"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Primanje upozorenja za ozbiljne prijetnje po život i imovinu"</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"AMBER upozorenja"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Primanje biltena o otmicama djece"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Ponovi"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Omogući Upravitelj poziva"</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Dopusti usluzi upravljanje načinom uspostavljanja poziva."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Upravitelj poziva"</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">"Pristupne točke"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="5808043757309522392">"Poboljšan 4G LTE način"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1376589643017218924">"Upotreba LTE podataka radi poboljšanja glasovnih značajki i komunikacije (preporučeno)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Željena vrsta mreže"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (preporučeno)"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"Radni SIM"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Pristup aplikacijama i sadržaju"</string>
    <string name="user_rename" msgid="8523499513614655279">"PREIMENOVANJE"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Postavljanje ograničenja aplikacije"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Kontrolira aplikacija <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Ta aplikacija može pristupiti vašim računima"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="6968697624437267294">"Aplikacija može pristupili vašim računima. Upravlja aplikacija <xliff:g id="APP">%1$s</xliff:g>."</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"Wi‑Fi i mobilne mreže"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Dopusti izmjenu postavki Wi‑Fi i mobilne mreže"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Dopusti izmjene uparivanja i postavki Bluetootha"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Dopusti 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">"Dopusti razmjenu podataka kada tablet dodiruje drugi uređaj"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Dopusti razmjenu podataka kada telefon dodiruje drugi uređaj"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Lokacija"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Dopusti aplikacijama da upotrebljavaju podatke o lokaciji"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Natrag"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Dalje"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Završi"</string>
    <string name="user_image_take_photo" msgid="1280274310152803669">"Snimite fotografiju"</string>
    <string name="user_image_choose_photo" msgid="7940990613897477057">"Odaberite fotografiju iz Galerije"</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Odabir slike"</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 se promijenile"</string>
    <string name="sim_cards_changed_message_summary" msgid="8258058274989383204">"Dodirnite da biste postavili aktivnosti"</string>
    <string name="sim_cellular_data_unavailable" msgid="9109302537004566098">"Mobilni podaci nisu dostupni"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="5416535001368135327">"Dodirnite da biste odabrali podatkovni SIM"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Uvijek upotrebljavaj za pozive"</string>
    <string name="select_sim_for_data" msgid="2366081042162853044">"Odaberite SIM za podatke"</string>
    <string name="data_switch_started" msgid="2040761479817166311">"Prebacuje se podatkovni SIM, to može potrajati najviše minutu..."</string>
    <string name="select_sim_for_calls" msgid="3503094771801109334">"Poziv putem usluge"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Odabir SIM kartice"</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 je prazan"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Naziv SIM-a"</string>
    <string name="sim_name_hint" msgid="7038643345238968930">"Unesite naziv SIM-a"</string>
    <string name="sim_editor_title" msgid="4034301817366627870">"Utor za SIM %1$d"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Mobilni 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">"Naranč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">"Uzvratni poziv sa 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">"Rastereti željenu mrežu"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Ne emitiraj naziv mreže"</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"Onemogućivanje emitiranja naziva mreže sprječava treće strane da pristupe podacima o vašoj mreži."</string>
    <string name="preferred_network_offload_popup" msgid="2252915199889604600">"Onemogućivanje emitiranja naziva mreže spriječit će automatsko povezivanje sa skrivenim mrežama."</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 kartica je promijenjena."</string>
    <string name="sim_notification_summary" msgid="8858043655706669772">"Dodirnite za postavljanje"</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 je 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="dashboard_suggestion_condition_footer_content_description" msgid="2898588191174845961">"Sažmi"</string>
    <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">"potrošnja podatkovnog prometa"</string>
    <string name="network_dashboard_summary_hotspot" msgid="8494210248613254574">"žarišna toč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 za vožnju, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="3840842725283655533">"Bluetooth, način 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 obavijesti"</string>
    <string name="app_and_notification_dashboard_summary" msgid="2363314178802548682">"Dopuštenja, zadane aplikacije"</string>
    <string name="notification_settings_work_profile" msgid="3186757479243373003">"Pristup obavijestima nije dostupan za aplikacije u 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="5797743225249766685">"Jezici, vrijeme, sigurnosna kopija, ažuriranja"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Postavke"</string>
    <string name="search_menu" msgid="6283419262313758339">"Pretraži postavke"</string>
    <string name="keywords_wifi" msgid="3646884600964177062">"wifi, wi-fi, mrežna veza, internet, bežično, podaci, wi fi"</string>
    <string name="keywords_change_wifi_state" msgid="627068244033681010">"wifi, wi-fi, promjena, upravljanje"</string>
    <string name="keywords_more_default_sms_app" msgid="8597706109432491909">"tekstna poruka, slanje tekstnih poruka, poruke, slanje poruka, zadano"</string>
    <string name="keywords_more_mobile_networks" msgid="8995946622054642367">"mobilno, mobilna mreža, mobilni operater, bežično, podaci, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="1784064367330122679">"Wi-Fi, wi-fi, poziv, pozivanje"</string>
    <string name="keywords_home" msgid="294182527446892659">"pokretač, zadano, aplikacije"</string>
    <string name="keywords_display" msgid="8910345814565493016">"zaslon, dodirni zaslon"</string>
    <string name="keywords_display_brightness_level" msgid="3138350812626210404">"zatamnjenje zaslona, dodirni zaslon, baterija, svijetlo"</string>
    <string name="keywords_display_night_display" msgid="2534032823231355074">"zatamnjenje zaslona, noć, nijansa, noćna smjena, svjetlina, boja zaslona, boja"</string>
    <string name="keywords_display_wallpaper" msgid="7362076351860131776">"pozadina, personalizirati, prilagoditi, zaslon"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"veličina teksta"</string>
    <string name="keywords_display_cast_screen" msgid="7684618996741933067">"projekt, emitiranje"</string>
    <string name="keywords_storage" msgid="3299217909546089225">"prostor, disk, tvrdi 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">"prepoznavanje, unos, govor, govoriti, jezik, bez ruku, uvredljiva, riječ, audio, povijest, bluetooth slušalice"</string>
    <string name="keywords_text_to_speech_output" msgid="5150660047085754699">"brzina, jezik, zadano, govoriti, govorenje, tekst u govor, pristupačnost, čitač zaslona, slijep"</string>
    <string name="keywords_date_and_time" msgid="758325881602648204">"sat, vojni prikaz"</string>
    <string name="keywords_network_reset" msgid="6024276007080940820">"poništavanje, vraćanje na zadano, vraćanje na tvorničke postavke, poništavanje"</string>
    <string name="keywords_factory_data_reset" msgid="2261491208836438871">"čišćenje, brisanje, oporavak, obrisati, uklanjanje, vraćanje na tvorničke postavke"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"pisač"</string>
    <string name="keywords_sounds" msgid="5633386070971736608">"zvučni signal zvučnika, zvučnik, glasnoća, utišano, tišina, zvuk, glazba"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="5426093074031208917">"ne ometaj, prekinuti, prekid, zaustaviti"</string>
    <string name="keywords_app" msgid="6334757056536837791">"RAM"</string>
    <string name="keywords_location" msgid="6615286961552714686">"u blizini, lokacija, povijest, izvješćivanje"</string>
    <string name="keywords_accounts" msgid="1957925565953357627">"račun"</string>
    <string name="keywords_users" msgid="3434190133131387942">"ograničenje, ograničiti, ograničeno"</string>
    <string name="keywords_keyboard_and_ime" msgid="9143339015329957107">"ispravak teksta, ispraviti, zvuk, vibracija, automatski, jezik, pokret, predložiti, prijedlog, tema, uvredljivo, riječ, upisivati, emoji, međunarodno"</string>
    <string name="keywords_reset_apps" msgid="5293291209613191845">"poništavanje, vraćanje na zadano, postavke, zadano"</string>
    <string name="keywords_emergency_app" msgid="3143078441279044780">"hitno, u hitnom slučaju, aplikacija, zadano"</string>
    <string name="keywords_default_phone_app" msgid="4213090563141778486">"telefon, brojčanik, zadano"</string>
    <string name="keywords_all_apps" msgid="7814015440655563156">"aplikacije, preuzimanje, sustav"</string>
    <string name="keywords_app_permissions" msgid="4229936435938011023">"aplikacije, dopuštenja, sigurnost"</string>
    <string name="keywords_default_apps" msgid="223872637509160136">"aplikacije, zadano"</string>
    <string name="keywords_ignore_optimizations" msgid="6102579291119055029">"zanemariti optimizacije, mirovanje, aplikacija u mirovanju"</string>
    <string name="keywords_color_mode" msgid="6362744316886077510">"živopisno, RGB, sRGB, boja, prirodno, standardno"</string>
    <string name="keywords_color_temperature" msgid="6239410718075715449">"temperatura, boja, D65, D73, bijela, žuta, plava, topla, hladna"</string>
    <string name="keywords_lockscreen" msgid="5746561909668570047">"kliziti prstom za otključavanje, zaporka, uzorak, PIN"</string>
    <string name="keywords_profile_challenge" msgid="789611397846512845">"radni izazov, radni, profil"</string>
    <string name="keywords_unification" msgid="1922900767659821025">"radni profil, upravljani profil, objediniti, objedinjavanje, radni, 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">"sigurnosno kopirati, sigurnosna kopija"</string>
    <string name="keywords_assist_gesture_launch" msgid="813968759791342591">"pokret"</string>
    <string name="keywords_face_unlock" msgid="5753804962088424662">"lice, otključavanje"</string>
    <string name="keywords_imei_info" msgid="7230982940217544527">"IMEI, MEID, min, verzija PRL-a, 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, roaming, ICCID"</string>
    <string name="keywords_model_and_hardware" msgid="1459248377212829642">"serijski broj, verzija hardvera"</string>
    <string name="keywords_android_version" msgid="9069747153590902819">"razina Androidove sigurnosne zakrpe, verzija osnovnog frekvencijskog pojasa, verzija jezgre"</string>
    <string name="keywords_systemui_theme" msgid="9112852512550404882">"tamna tema"</string>
    <string name="keywords_device_feedback" msgid="564493721125966719">"programska pogreška"</string>
    <string name="keywords_ambient_display_screen" msgid="5874969496073249362">"Ambijentalni zaslon, prikaz zaključanog zaslona"</string>
    <string name="keywords_face_settings" msgid="7505388678116799329">"lice"</string>
    <string name="keywords_fingerprint_settings" msgid="239222512315619538">"otisak prsta"</string>
    <string name="keywords_display_auto_brightness" msgid="4130320471533951796">"zatamnjenje zaslona, dodirni zaslon, baterija, pametna svjetlina, dinamična svjetlina"</string>
    <string name="keywords_auto_rotate" msgid="5620879898668211494">"zakrenuti, okrenuti, rotacija, portret, pejzaž, usmjerenje, okomito, vodoravno"</string>
    <string name="keywords_system_update_settings" msgid="7752189778843741773">"nadogradnja, android"</string>
    <string name="keywords_zen_mode_settings" msgid="6526742836231604995">"dnd, raspored, obavijesti, blokiranje, tišina, vibracija, mirovanje, rad, fokus, zvuk, utišano, dan, dan u tjednu, vikend, noć tijekom tjedna, događaj"</string>
    <string name="keywords_screen_timeout" msgid="8161370660970309476">"zaslon, vrijeme zaključavanja, vrijeme čekanja, zaključan zaslon"</string>
    <string name="keywords_storage_settings" msgid="1642340184392317296">"memorija, podaci, brisanje, čišćenje, slobodno, prostor"</string>
    <string name="keywords_bluetooth_settings" msgid="6804844062789439858">"povezano, uređaj, slušalice, slušalice s mikrofonom, zvučnik, bežično, uparivanje, slušalice za umetanje u uho, glazba, medij"</string>
    <string name="keywords_wallpaper" msgid="5058364390917429896">"pozadina, zaslon, zaključan zaslon, tema"</string>
    <string name="keywords_assist_input" msgid="5017533309492679287">"zadano, pomoćno"</string>
    <string name="keywords_default_browser" msgid="8324486019657636744">"zadano, zadani preglednik"</string>
    <string name="keywords_default_payment_app" msgid="3838565809518896799">"plaćanje, zadano"</string>
    <string name="keywords_default_links" msgid="5830406261253835547">"zadano"</string>
    <string name="keywords_ambient_display" msgid="3103487805748659132">"dolazna obavijest"</string>
    <string name="keywords_hotspot_tethering" msgid="1137511742967410918">"usb modemsko povezivanje, bluetooth modemsko povezivanje, wifi žarišna točka"</string>
    <string name="keywords_touch_vibration" msgid="5983211715076385822">"taktilnost, vibracija, zaslon, osjetljivost"</string>
    <string name="keywords_ring_vibration" msgid="2393528037008999296">"taktilnost, vibracija, telefon, poziv, osjetljivost"</string>
    <string name="setup_wifi_nfc_tag" msgid="9028353016222911016">"Postavite oznaku NFC za Wi-Fi"</string>
    <string name="write_tag" msgid="8571858602896222537">"Piši"</string>
    <string name="status_awaiting_tap" msgid="2130145523773160617">"Dodirnite oznaku da biste zapisali podatke..."</string>
    <string name="status_invalid_password" msgid="2575271864572897406">"Nevažeća zaporka, pokušajte ponovo."</string>
    <string name="status_write_success" msgid="5228419086308251169">"Uspjeli ste!"</string>
    <string name="status_failed_to_write" msgid="8072752734686294718">"Nije moguće zapisati podatke u oznaku NFC. Ako problem potraje, pokušajte upotrijebiti drugačiju oznaku."</string>
    <string name="status_tag_not_writable" msgid="2511611539977682175">"U oznaku NFC ne mogu se zapisati podaci. Upotrijebite drugačiju oznaku."</string>
    <string name="default_sound" msgid="8821684447333687810">"Zadani zvuk"</string>
    <string name="sound_settings_summary" msgid="4100853606668287965">"Glasnoća zvona na <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="3402435125958012986">"Glasnoća, vibracija, Ne ometaj"</string>
    <string name="sound_settings_summary_vibrate" msgid="1869282574422220096">"Softver zvona postavljen na vibraciju"</string>
    <string name="sound_settings_summary_silent" msgid="5074529767435584948">"Softver zvona postavljen na nečujno"</string>
    <string name="sound_settings_example_summary" msgid="2404914514266523165">"Glasnoća zvona na 80%"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Glasnoća medija"</string>
    <string name="call_volume_option_title" msgid="1265865226974255384">"Glasnoća poziva"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Glasnoća alarma"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Glasnoća zvona"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Glasnoća obavijesti"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Melodija zvona telefona"</string>
    <string name="notification_ringtone_title" msgid="4468722874617061231">"Zadani zvuk obavijesti"</string>
    <string name="notification_unknown_sound_title" msgid="2535027767851838335">"Zvuk koji pruža aplikacija"</string>
    <string name="notification_sound_default" msgid="565135733949733766">"Zadani zvuk obavijesti"</string>
    <string name="alarm_ringtone_title" msgid="6344025478514311386">"Zadani zvuk alarma"</string>
    <string name="vibrate_when_ringing_title" msgid="3806079144545849032">"Vibracija i za pozive"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Ostali zvukovi"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Tonovi brojčanika"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Zvukovi zaključavanja zaslona"</string>
    <string name="charging_sounds_title" msgid="1132272552057504251">"Zvukovi punjenja"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Zvukovi priključivanja"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Zvukovi dodirivanja"</string>
    <string name="vibrate_on_touch_title" msgid="1510405818894719079">"Vibracija za dodir"</string>
    <string name="vibrate_on_touch_summary" msgid="8015901758501868229">"Dodirne povratne informacije za dodir, tipkovnicu i više"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Priključna stanica reproducira"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Sve zvukove"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Samo medijske zvukove"</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či zvukove"</string>
    <string name="zen_mode_settings_summary_off" msgid="6119891445378113334">"Nikada"</string>
    <plurals name="zen_mode_settings_summary_on" formatted="false" msgid="7346979080337117366">
      <item quantity="one"><xliff:g id="ON_COUNT">%d</xliff:g> pravilo</item>
      <item quantity="few"><xliff:g id="ON_COUNT">%d</xliff:g> pravila</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> pravila</item>
    </plurals>
    <string name="zen_mode_settings_title" msgid="1066226840983908121">"Ne ometaj"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="2297134204747331078">"Uključite opciju Ne uznemiravaj."</string>
    <string name="zen_mode_behavior_settings_title" msgid="5453115212674008032">"Iznimke"</string>
    <string name="zen_mode_duration_settings_title" msgid="229547412251222757">"Trajanje"</string>
    <string name="zen_mode_behavior_allow_title" msgid="3845615648136218141">"Dopusti zvukove 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 alarma i medija"</string>
    <string name="zen_mode_automation_settings_title" msgid="2517800938791944915">"Uključi automatski"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="7069221762714457987">"Automatska pravila"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="9041488774587594301">"Automatsko pravilo"</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 Ne uznemiravaj"</string>
    <string name="zen_mode_use_automatic_rule" msgid="4509513632574025380">"Upotrijebi pravilo"</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 vizualnih ometanja"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="6308824824208120508">"Dopusti vizualne signale"</string>
    <string name="zen_mode_settings_category" msgid="3982039687186952865">"Kada je uključen način Ne uznemiravaj"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="478040192977063582">"Obavijesti"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="3690261619682396872">"Bez zvuka obavijesti"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="5810076116489877312">"Vidjet ćete obavijesti na zaslonu"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="3465600930732602159">"Kada obavijesti stignu, telefon neće davati zvučne signale niti vibrirati."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5305121630186687339">"Bez vizualnih i zvučnih signala obavijesti"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="7555448406901864904">"Obavijesti se neće prikazivati niti davati zvučne signale"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="6559283246372102465">"Na telefonu se neće prikazivati nove ni postojeće obavijesti i neće biti zvučnih signala ni vibriranja. Obavijesti se neće prikazivati kada prijeđete prstom prema dolje od vrha zaslona.\n\nNapominjemo da će se obavijesti kritične za aktivnost i status telefona i dalje prikazivati."</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">"Bez zvuka obavijesti"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="7416121534987213074">"Djelomično skriveno"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="3618285192806732504">"Bez vizualnih i zvučnih signala obavijesti"</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">"Kad je zaslon uključen"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="4276414460889400625">"Kad je zaslon 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">"Ne uključuj zaslon"</string>
    <string name="zen_mode_block_effect_light" msgid="8106976110224107316">"Ne upotrebljavaj treperenje svjetla"</string>
    <string name="zen_mode_block_effect_peek" msgid="6836997464098657115">"Ne prikazuj obavijesti na zaslonu"</string>
    <string name="zen_mode_block_effect_status" msgid="6642532634292373081">"Ne prikazuj ikone na traci statusa"</string>
    <string name="zen_mode_block_effect_badge" msgid="4656911773512844243">"Ne prikazuj točke obavijesti"</string>
    <string name="zen_mode_block_effect_ambient" msgid="4704755879961212658">"Ne aktiviraj za obavijesti"</string>
    <string name="zen_mode_block_effect_list" msgid="3882541635576592530">"Ne prikazuj na popisu obavijesti"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="2617875282623486256">"Nikad"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="1230265589026355094">"Kad je zaslon isključen"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="6017536991063513394">"Kad je zaslon 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 vizualni znakovi obavijesti"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="1213328945418248026">"Zvuk, vibracija i vizualni znakovi obavijesti"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="5710896246703497760">"Obavijesti potrebne za osnovne aktivnosti i status telefona nikad se neće skrivati"</string>
    <string name="zen_mode_no_exceptions" msgid="7653433997399582247">"Ništa"</string>
    <string name="zen_mode_other_options" msgid="520015080445012355">"ostale 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">"Odmah isključi"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8860646554263965569">"Način Ne uznemiravaj uključen je do <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="7186615007561990908">"Način Ne ometaj ostat će uključen dok ga ne isključite"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="7780048616476170427">"Način Ne uznemiravaj automatski je uključilo pravilo (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="1721179577382915270">"Način Ne uznemiravaj automatski je uključila aplikacija (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_interruption_level_priority" msgid="2078370238113347720">"Samo prioritetno"</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 (ako se ne uključuje automatski)"</string>
    <string name="zen_mode_duration_summary_forever" msgid="3144786357459137066">"Dok ne isključite (ako se ne uključuje automatski)"</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 (ako se ne uključuje automatski)</item>
      <item quantity="few"><xliff:g id="NUM_HOURS">%d</xliff:g> sata (ako se ne uključuje automatski)</item>
      <item quantity="other"><xliff:g id="NUM_HOURS">%d</xliff:g> sati (ako se ne uključuje automatski)</item>
    </plurals>
    <string name="zen_mode_duration_summary_time_minutes" msgid="3959860288930526323">"<xliff:g id="NUM_MINUTES">%d</xliff:g> min (ako se ne uključuje automatski)"</string>
    <plurals name="zen_mode_sound_summary_summary_off_info" formatted="false" msgid="8115159143760078050">
      <item quantity="one"><xliff:g id="ON_COUNT">%d</xliff:g> pravilo može se uključiti automatski</item>
      <item quantity="few"><xliff:g id="ON_COUNT">%d</xliff:g> pravila mogu se uključiti automatski</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> pravila može se uključiti automatski</item>
    </plurals>
    <string name="zen_category_behavior" msgid="2989256030084350296">"Ponašanje"</string>
    <string name="zen_category_exceptions" msgid="7601136604273265629">"Iznimke"</string>
    <string name="zen_category_schedule" msgid="9000447592251450453">"Raspored"</string>
    <string name="zen_sound_title" msgid="424490228488531372">"Zvuk i vibracija"</string>
    <string name="zen_sound_footer" msgid="7621745273287208979">"Kada je način Ne uznemiravaj uključen, zvučni signali i vibriranje bit će isključeni, osim za prethodno navedene stavke koje dopustite."</string>
    <string name="zen_sound_category_title" msgid="4336596939661729188">"Zanemari sve osim"</string>
    <string name="zen_sound_all_muted" msgid="4850363350480968114">"Zanemareno"</string>
    <string name="zen_sound_none_muted" msgid="3938508512103612527">"Nije zanemareno"</string>
    <string name="zen_sound_one_allowed" msgid="8447313454438932276">"Zanemareno, ali dopusti <xliff:g id="SOUND_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_sound_two_allowed" msgid="980491120444358550">"Zanemareno, ali dopusti <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">"Zanemareno, ali dopusti <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_msg_event_reminder_title" msgid="5137894077488924820">"Poruke, događaji i podsjetnici"</string>
    <string name="zen_msg_event_reminder_footer" msgid="4376930591019535192">"Kada je način Ne uznemiravaj uključen, zanemarit će se poruke, podsjetnici i događaji, osim prethodno navedenih stavki koje dopustite. Možete prilagoditi postavke poruka da bi vaša obitelj, prijatelji ili drugi kontakti mogli stupiti u kontakt s vama."</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">"Bez vizualnih i zvučnih signala obavijesti"</string>
    <string name="zen_onboarding_current_setting_title" msgid="776426065129609376">"Bez zvuka obavijesti"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="6293026064871880706">"Obavijesti se neće prikazivati niti davati zvučne signale. Dopušteni su pozivi kontakata označenih zvjezdicom i ponovnih pozivatelja."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="1280614488924843713">"(Trenutačna postavka)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="1352808651270918932">"Želite li promijeniti postavke obavijesti za način Ne uznemiravaj?"</string>
    <string name="sound_work_settings" msgid="6774324553228566442">"Zvukovi radnog profila"</string>
    <string name="work_use_personal_sounds_title" msgid="1148331221338458874">"Upotreba zvuka osobnog profila"</string>
    <string name="work_use_personal_sounds_summary" msgid="6207040454949823153">"Zvukovi su isti za radni i osobni profil"</string>
    <string name="work_ringtone_title" msgid="5806657896300235315">"Melodija zvona radnog telefona"</string>
    <string name="work_notification_ringtone_title" msgid="6081247402404510004">"Zadani zvuk radne obavijesti"</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 osobni profil"</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 osobnog profila upotrebljavat će se za vaš radni profil"</string>
    <string name="ringtones_install_custom_sound_title" msgid="5948792721161302255">"Dodati prilagođeni zvuk?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="2195581481608512786">"Ova će se datoteka kopirati u mapu <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">"Obavijesti"</string>
    <string name="recent_notifications" msgid="5660639387705060156">"Nedavno poslano"</string>
    <string name="recent_notifications_see_all_title" msgid="8572160812124540326">"Prikaži sve u posljednjih 7 dana"</string>
    <string name="advanced_section_header" msgid="8833934850242546903">"Napredno"</string>
    <string name="profile_section_header" msgid="2320848161066912001">"Obavijesti s radnog profila"</string>
    <string name="notification_badging_title" msgid="5938709971403474078">"Dopusti točke obavijesti"</string>
    <string name="notification_pulse_title" msgid="1905382958860387030">"Trepereće svjetlo"</string>
    <string name="lock_screen_notifications_title" msgid="2583595963286467672">"Na zaključanom zaslonu"</string>
    <string name="locked_work_profile_notification_title" msgid="8327882003361551992">"Kad je radni profil zaključan"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Prikaži sav sadržaj obavijesti"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="8301305044690264958">"Sakrij osjetljiv sadržaj"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="859628910427886715">"Uopće ne prikazuj obavijesti"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6164532459432182244">"Kako želite da se prikazuju obavijesti kad je uređaj zaključan?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1416589393106326972">"Obavijesti"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="835870815661120772">"Prikaži sav sadržaj obavijesti radnog profila"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2005907007779384635">"Sakrij osjetljiv sadržaj s posla"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="8307705621027472346">"Kako želite da se prikazuju obavijesti profila kada je uređaj zaključan?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="3169806586032521333">"Obavijesti profila"</string>
    <string name="notifications_title" msgid="8086372779371204971">"Obavijesti"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Obavijesti aplikacije"</string>
    <string name="notification_channel_title" msgid="2260666541030178452">"Kategorija obavijesti"</string>
    <string name="notification_group_title" msgid="7180506440133859601">"Grupa kategorija obavijesti"</string>
    <string name="notification_importance_title" msgid="4368578960344731828">"Ponašanje"</string>
    <string name="notification_importance_unspecified" msgid="6622173510486113958">"Dopusti zvuk"</string>
    <string name="notification_importance_blocked" msgid="7938180808339386300">"Nikad ne prikazuj obavijesti"</string>
    <string name="notification_importance_min" msgid="9054819132085066824">"Prikaži tiho i minimiziraj"</string>
    <string name="notification_importance_low" msgid="2445139943005315690">"Prikaži tiho"</string>
    <string name="notification_importance_default" msgid="5958338024601957516">"Reproduciraj zvuk"</string>
    <string name="notification_importance_high" msgid="2082429479238228527">"Reproduciraj zvuk i prikaži na zaslonu"</string>
    <string name="notification_importance_high_silent" msgid="2667033773703765252">"Skočni zaslon"</string>
    <string name="notification_importance_min_title" msgid="6974673091137544803">"Niska"</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="3058778300264746473">"Hitna"</string>
    <string name="allow_interruption" msgid="7136150018111848721">"Dopusti ometanja"</string>
    <string name="allow_interruption_summary" msgid="7870159391333957050">"Aplikacija može emitirati zvuk, vibrirati i/ili prikazivati obavijesti na zaslonu"</string>
    <string name="notification_channel_summary_min" msgid="5401718014765921892">"Mala važnost"</string>
    <string name="notification_channel_summary_low" msgid="322317684244981244">"Srednja važnost"</string>
    <string name="notification_channel_summary_default" msgid="1111749130423589931">"Velika važnost"</string>
    <string name="notification_channel_summary_high" msgid="2085017556511003283">"Hitno"</string>
    <string name="notification_switch_label" msgid="6843075654538931025">"Prikaži obavijesti"</string>
    <string name="default_notification_assistant" msgid="7631945224761430146">"Pomoćnik za obavijesti"</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> tjedno"</string>
    <string name="notifications_sent_never" msgid="1001964786456700536">"Nikada"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Pristup obavijestima"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8748026238701253040">"Blokiran je pristup obavijestima radnog profila"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Aplikacije ne mogu čitati obavijesti"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="7930130030691218387">
      <item quantity="one">%d aplikacija može čitati obavijesti</item>
      <item quantity="few">%d aplikacije mogu čitati obavijesti</item>
      <item quantity="other">%d aplikacija može čitati obavijesti</item>
    </plurals>
    <string name="no_notification_listeners" msgid="3487091564454192821">"Nijedna instalirana aplikacija nije zatražila pristup obavijestima."</string>
    <string name="notification_listener_security_warning_title" msgid="5522924135145843279">"Želite li dopustiti usluzi <xliff:g id="SERVICE">%1$s</xliff:g> pristup obavijestima?"</string>
    <string name="notification_listener_security_warning_summary" msgid="119203147791040151">"Aplikacija <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> moći će čitati sve obavijesti, uključujući osobne podatke kao što su imena kontakata i tekst poruka koje primate. Moći će i odbacivati obavijesti ili pokretati gumbe za radnje koje obavijesti sadrže. \n\nAplikacija će također moći uključiti ili isključiti značajku Ne ometaj i promijeniti povezane postavke."</string>
    <string name="notification_listener_disable_warning_summary" msgid="6738915379642948000">"Ako isključite pristup obavijestima za <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, možda će se isključiti i pristup značajci Ne ometaj."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="8333442186428083057">"Isključi"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8586417377104211584">"Odustani"</string>
    <string name="vr_listeners_title" msgid="1318901577754715777">"Pomoćne usluge za virtualnu stvarnost"</string>
    <string name="no_vr_listeners" msgid="2689382881717507390">"Nijedna instalirana aplikacija nije zatražila da se pokrene kao pomoćna usluga za virtualnu stvarnost."</string>
    <string name="vr_listener_security_warning_title" msgid="8309673749124927122">"Želite li dopustiti pristup usluge virtualne stvarnosti za uslugu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="6931541068825094653">"Usluga <xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> moći će se pokrenuti kada budete upotrebljavali aplikacije u načinu rada virtualne stvarnosti."</string>
    <string name="display_vr_pref_title" msgid="8104485269504335481">"Kada je uređaj u VR-u"</string>
    <string name="display_vr_pref_low_persistence" msgid="5707494209944718537">"Smanji zamućenje (preporučeno)"</string>
    <string name="display_vr_pref_off" msgid="2190091757123260989">"Smanji treperenje"</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 slike u slici"</string>
    <string name="picture_in_picture_keywords" msgid="8361318686701764690">"slika u slici"</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">"Dopusti sliku u slici"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="1264019085827708920">"Omogućite da ova aplikacija izradi prozor sa slikom u slici dok je otvorena ili kad izađete iz nje (npr. da biste nastavili gledati videozapis). Taj se prozor prikazuje iznad drugih aplikacija koje upotrebljavate."</string>
    <string name="manage_zen_access_title" msgid="2611116122628520522">"Pristup opciji Ne ometaj"</string>
    <string name="zen_access_empty_text" msgid="8772967285742259540">"Nijedna instalirana aplikacija nije zatražila pristup opciji Ne ometaj"</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Učitavanje aplikacija..."</string>
    <string name="app_notifications_off_desc" msgid="8289223211387083447">"Android na vaš zahtjev blokira prikazivanje obavijesti te aplikacije na ovom uređaju"</string>
    <string name="channel_notifications_off_desc" msgid="9013011134681491778">"Android na vaš zahtjev blokira prikazivanje te kategorije obavijesti na ovom uređaju"</string>
    <string name="channel_group_notifications_off_desc" msgid="2315252834146837470">"Android na vaš zahtjev blokira prikazivanje te grupe obavijesti na ovom uređaju"</string>
    <string name="notification_channels" msgid="5346841743182627500">"Kategorije"</string>
    <string name="notification_channels_other" msgid="5645317113885788226">"Drugo"</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 nijednu obavijest"</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">Izbrisana je <xliff:g id="COUNT_1">%d</xliff:g> kategorija</item>
      <item quantity="few">Izbrisane su <xliff:g id="COUNT_1">%d</xliff:g> kategorije</item>
      <item quantity="other">Izbrisano je <xliff:g id="COUNT_1">%d</xliff:g> kategorija</item>
    </plurals>
    <string name="notification_toggle_on" msgid="650145396718191048">"Uključene"</string>
    <string name="notification_toggle_off" msgid="2142010737190671762">"Isključene"</string>
    <string name="app_notification_block_title" msgid="4069351066849087649">"Blokiraj sve"</string>
    <string name="app_notification_block_summary" msgid="4744020456943215352">"Nikad ne prikazuj te obavijesti"</string>
    <string name="notification_content_block_title" msgid="5854232570963006360">"Prikaži obavijesti"</string>
    <string name="notification_content_block_summary" msgid="7746185794438882389">"Nikad ne prikazuj obavijesti na zaslonu obavijesti ili na perifernim uređajima"</string>
    <string name="notification_badge_title" msgid="6370122441168519809">"Dopusti točku obavijesti"</string>
    <string name="notification_channel_badge_title" msgid="2240827899882847087">"Prikaži točku obavijesti"</string>
    <string name="app_notification_override_dnd_title" msgid="7867458246395884830">"Nadjačaj Ne ometaj"</string>
    <string name="app_notification_override_dnd_summary" msgid="2612502099373472686">"Dopusti obavijesti u načinu Ne ometaj kad je postavljen na \"Samo prioritetno\""</string>
    <string name="app_notification_visibility_override_title" msgid="7821124557634786985">"Na zaključanom zaslonu"</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"Blokirano"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Prioritet"</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">"Trepereće svjetlo"</string>
    <string name="notification_vibrate_title" msgid="1646667807969755957">"Vibriranje"</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="5149068059383837549">"Naziv pravila"</string>
    <string name="zen_mode_rule_name_hint" msgid="3781174510556433384">"Unesite naziv pravila"</string>
    <string name="zen_mode_rule_name_warning" msgid="4517805381294494314">"Naziv pravila već se upotrebljava"</string>
    <string name="zen_mode_add_rule" msgid="9100929184624317193">"Dodaj pravilo"</string>
    <string name="zen_mode_add_event_rule" msgid="3997335103633946552">"Dodajte pravilo za događaje"</string>
    <string name="zen_mode_add_time_rule" msgid="5002080000597838703">"Dodajte pravilo za vrijeme"</string>
    <string name="zen_mode_delete_rule" msgid="2985902330199039533">"Izbriši pravilo"</string>
    <string name="zen_mode_choose_rule_type" msgid="5423746638871953459">"Odaberite vrstu pravila"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6237882294348570283">"Želite li 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">"Te se postavke trenutačno ne mogu promijeniti. Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> automatski je uključila način Ne uznemiravaj s prilagođenim ponašanjem."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="2558968232814237874">"Te se postavke trenutačno ne mogu promijeniti. Neka je aplikacija automatski uključila način Ne uznemiravaj s prilagođenim ponašanjem."</string>
    <string name="zen_mode_qs_set_behavior" msgid="6200424436456086312">"Te se postavke trenutačno ne mogu promijeniti. Način Ne uznemiravaj ručno je uključen s prilagođenim ponašanjem."</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 na uključivanje opcije \"Ne ometaj\" tijekom navedenih vremena"</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 je na uključivanje opcije \"Ne ometaj\" tijekom navedenih događaja"</string>
    <string name="zen_mode_event_rule_calendar" msgid="8787906563769067418">"Tijekom događaja za"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="5135844750232403975">"Tijekom 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">"Kada 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">"Kada je odgovor"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="8868873496008825961">"Da, Možda ili Nije odgovorio"</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čeno/<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">"Ništa"</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 nadjačati vrijeme završetka"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="4597050434723180422">"Zaustavi kada vrijeme istekne ili nakon sljedećeg alarma, ovisno o tome što će se dogoditi prije"</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> – <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_calls" msgid="7051492091133751208">"Pozivi"</string>
    <string name="zen_mode_calls_title" msgid="623395033931747661">"Dopusti pozive"</string>
    <string name="zen_mode_calls_footer" msgid="3618700268458237781">"Kada je način Ne uznemiravaj uključen, dolazni se pozivi blokiraju. Možete prilagoditi postavke da bi vaša obitelj, prijatelji ili drugi kontakti mogli stupiti u kontakt s vama."</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="5886440273537510894">"Poruke"</string>
    <string name="zen_mode_messages_title" msgid="7729380010396411129">"Dopusti poruke"</string>
    <string name="zen_mode_all_messages" msgid="8257021584561639816">"Poruke"</string>
    <string name="zen_mode_all_messages_list" msgid="4223560721230967061">"poruke"</string>
    <string name="zen_mode_selected_messages" msgid="1047355526202106114">"Neke poruke"</string>
    <string name="zen_mode_selected_messages_list" msgid="5309288435815759102">"neke poruke"</string>
    <string name="zen_mode_from_anyone" msgid="2638322015361252161">"Od svakoga"</string>
    <string name="zen_mode_from_contacts" msgid="2232335406106711637">"Samo od kontakata"</string>
    <string name="zen_mode_from_starred" msgid="2678345811950997027">"Samo od kontakata sa zvjezdicom"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="4046151920710059778">"Kontakti označeni zvjezdicom i ponovni pozivatelji"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="1528716671301999084">"Kontakti i ponovni pozivatelji"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7105261473107715445">"Samo ponovni pozivatelji"</string>
    <string name="zen_mode_from_none" msgid="8219706639954614136">"Ništa"</string>
    <string name="zen_mode_alarms" msgid="2165302777886552926">"Alarmi"</string>
    <string name="zen_mode_alarms_list" msgid="1090332840207025714">"alarmi"</string>
    <string name="zen_mode_media" msgid="8808264142134422380">"Mediji"</string>
    <string name="zen_mode_media_list" msgid="5483540766397328038">"mediji"</string>
    <string name="zen_mode_system" msgid="2541380718411593581">"Zvukovi dodirivanja"</string>
    <string name="zen_mode_system_list" msgid="6996104733185177115">"zvukovi dodirivanja"</string>
    <string name="zen_mode_reminders" msgid="5458502056440485730">"Podsjetnici"</string>
    <string name="zen_mode_reminders_list" msgid="2853975802240340190">"podsjetnici"</string>
    <string name="zen_mode_reminders_title" msgid="2345044406347406902">"Dopusti podsjetnike"</string>
    <string name="zen_mode_events" msgid="7914446030988618264">"Događaji"</string>
    <string name="zen_mode_events_list" msgid="5571368229052715098">"događaji"</string>
    <string name="zen_mode_events_title" msgid="5597241655883329085">"Dopusti događaje"</string>
    <string name="zen_mode_all_callers" msgid="2378065871253871057">"svi"</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">"Uzastopni pozivi"</string>
    <string name="zen_mode_repeat_callers_list" msgid="2529895519653237330">"ponovni pozivatelji"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8553876328249671783">"Dopusti ponovne pozivatelje"</string>
    <string name="zen_mode_calls_summary_one" msgid="3972333792749874863">"Vrsta pozivatelja: <xliff:g id="CALLER_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_mode_calls_summary_two" msgid="6592821501321201329">"<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">"Ako ista osoba nazove drugi put unutar <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 uključi"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Nikada"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Svake noći"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Noći radnih dana"</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> sutra"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="2061973221027570123">"Promijeni na \"Samo alarmi\" na neodređeno vrijeme"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="6122003583875424601">
      <item quantity="one">Promijeni na \"Samo alarmi\" u trajanju od <xliff:g id="DURATION">%1$d</xliff:g> minute (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">Promijeni na \"Samo alarmi\" u trajanju od <xliff:g id="DURATION">%1$d</xliff:g> minute (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Promijeni na \"Samo alarmi\" u trajanju od <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">Promijeni na \"Samo alarmi\" u trajanju od <xliff:g id="DURATION">%1$d</xliff:g> sata do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="few">Promijeni na \"Samo alarmi\" u trajanju od <xliff:g id="DURATION">%1$d</xliff:g> sata do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="other">Promijeni na \"Samo alarmi\" u trajanju od <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">"Promijeni na \"Samo alarmi\" do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="6172985102689237703">"Promijeni na \"Uvijek prekidaj\""</string>
    <string name="zen_mode_screen_on" msgid="8774571998575673502">"Kada je zaslon uključen"</string>
    <string name="zen_mode_screen_on_summary" msgid="2208664848367443505">"Obavijesti utišane opcijom Ne uznemiravaj pojavit će se na zaslonu i prikazati ikonu trake statusa"</string>
    <string name="zen_mode_screen_off" msgid="3144446765110327937">"Kada je zaslon isključen"</string>
    <string name="zen_mode_screen_off_summary" msgid="7430034620565812258">"Obavijesti utišane opcijom Ne ometaj uključit će zaslon i aktivirati svjetlosni signal"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="2826121465026642017">"Obavijesti utišane opcijom Ne ometaj uključit će zaslon"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Postavke obavijesti"</string>
    <string name="suggestion_button_text" msgid="3275010948381252006">"U redu"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Pošalji povr. informacije o uređaju"</string>
    <string name="restr_pin_enter_admin_pin" msgid="1085834515677448072">"Unesite 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">"Prikvačivanje zaslona"</string>
    <string name="screen_pinning_description" msgid="1110847562111827766">"Kada je ta postavka uključena, možete prikvačiti trenutačni zaslon da bi ostao u prednjem planu dok ga ne otkvačite.\n\nDa biste upotrebljavali prikačivanje zaslona:\n\n1. Provjerite je li ta značajka uključena.\n\n2. Otvorite Pregled.\n\n3. Dodirnite ikonu aplikacije pri vrhu zaslona, a zatim dodirnite Prikvači."</string>
    <string name="screen_pinning_unlock_pattern" msgid="8282268570060313339">"Traži uzorak za otključavanje radi otkvačivanja"</string>
    <string name="screen_pinning_unlock_pin" msgid="8757588350454795286">"Traži PIN radi otkvačivanja"</string>
    <string name="screen_pinning_unlock_password" msgid="2514079566873826434">"Traži zaporku radi otkvačivanja"</string>
    <string name="screen_pinning_unlock_none" msgid="3814188275713871856">"Zaključaj uređaj prilikom otkvačivanja"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2232461523882170874">"Ovim radnim profilom upravlja:"</string>
    <string name="managing_admin" msgid="8843802210377459055">"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">"Ovaj uređaj možete dodatno zaštititi zahtijevanjem PIN-a kako bi se pokrenuo. Dok se ne pokrene, uređaj ne može primati pozive, poruke ili obavijesti, uključujući alarme.\n\nNa taj se način štite podaci na izgubljenim ili ukradenim uređajima. Želite li zahtijevati PIN za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_pattern" msgid="7081249914068568570">"Ovaj uređaj možete dodatno zaštititi zahtijevanjem uzorka kako bi se pokrenuo. Dok se ne pokrene, uređaj ne može primati pozive, poruke ili obavijesti, uključujući alarme. \n\nNa taj se način štite podaci na izgubljenim ili ukradenim uređajima. Želite li zahtijevati uzorak za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_password" msgid="7796567133897436443">"Ovaj uređaj možete dodatno zaštititi zahtijevanjem zaporke kako bi se pokrenuo. Dok se ne pokrene, uređaj ne može primati pozive, poruke ni obavijesti, uključujući alarme. \n\nNa taj se način štite podaci na izgubljenim ili ukradenim uređajima. Želite li zahtijevati zaporku za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="4550632760119547492">"Osim otključavanja uređaja otiskom prsta, uređaj možete dodatno zaštititi zahtijevanjem PIN-a kako bi se pokrenuo. Dok se ne pokrene, uređaj ne može primati pozive, poruke ili obavijesti, uključujući alarme.\n\nNa taj se način štite podaci na izgubljenim ili ukradenim uređajima. Želite li zahtijevati PIN za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="932184823193006087">"Osim otključavanja uređaja otiskom prsta, uređaj možete dodatno zaštititi zahtijevanjem uzorka kako bi se pokrenuo. Dok se ne pokrene, uređaj ne može primati pozive, poruke ili obavijesti, uključujući alarme.\n\nNa taj se način štite podaci na izgubljenim ili ukradenim uređajima. Želite li zahtijevati uzorak za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="5560954719370251702">"Osim otključavanja uređaja otiskom prsta, ovaj uređaj možete zaštititi i zahtijevanjem zaporke prije pokretanja. Dok se uređaj ne pokrene, ne može primati pozive, poruke i obavijesti, uključujući alarme.\n\nTime se štite podaci na izgubljenim i ukradenim uređajima. Želite li zahtijevati zaporku za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_pin_for_face" msgid="2017438765366716760">"Osim otključavanja uređaja licem, uređaj možete dodatno zaštititi zahtijevanjem PIN-a kako bi se pokrenuo. Dok se ne pokrene, uređaj ne može primati pozive, poruke ni obavijesti, uključujući alarme.\n\nTime se štite podaci na izgubljenim ili ukradenim uređajima. Želite li zahtijevati PIN za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_pattern_for_face" msgid="3551827507967661552">"Osim otključavanja uređaja licem, uređaj možete dodatno zaštititi zahtijevanjem uzorka kako bi se pokrenuo. Dok se ne pokrene, uređaj ne može primati pozive, poruke ni obavijesti, uključujući alarme.\n\nTime se štite podaci na izgubljenim ili ukradenim uređajima. Želite li zahtijevati uzorak za pokretanje uređaja?"</string>
    <string name="encryption_interstitial_message_password_for_face" msgid="3452793542112093614">"Osim otključavanja uređaja licem, ovaj uređaj možete zaštititi i zahtijevanjem zaporke prije pokretanja. Dok se uređaj ne pokrene, ne može primati pozive, poruke ni obavijesti, uključujući alarme.\n\nTime se štite podaci na izgubljenim i ukradenim uređajima. Želite li zahtijevati zaporku 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čeno"</string>
    <string name="restricted_false_label" msgid="3279282180297058755">"Može trošiti bateriju u pozadini"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"Zahtijevanje PIN-a?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"Zahtijevanje uzorka?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"Zahtijevanje zaporke?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="7582096542997635316">"Kada unesete PIN za pokretanje uređaja, usluge pristupačnosti, kao što je <xliff:g id="SERVICE">%1$s</xliff:g>, još neće biti dostupne."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="2020083142199612743">"Kada unesete uzorak za pokretanje uređaja, usluge pristupačnosti, kao što je <xliff:g id="SERVICE">%1$s</xliff:g>, još neće biti dostupne."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="4155875981789127796">"Kada unesete zaporku za pokretanje uređaja, usluge pristupačnosti, kao što je <xliff:g id="SERVICE">%1$s</xliff:g>, još neće biti dostupne."</string>
    <string name="direct_boot_unaware_dialog_message" msgid="2433632805847985867">"Napomena: ako ponovo pokrenete telefon i postavite zaključavanje zaslona, ova se aplikacija ne može pokrenuti dok ne otključate telefon"</string>
    <string name="imei_information_title" msgid="8499085421609752290">"Informacije IMEI-ja"</string>
    <string name="imei_information_summary" msgid="2074095606556565233">"Relativne informacije IMEI-ja"</string>
    <string name="slot_number" msgid="3762676044904653577">"(Utor <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="1840761193189009248">"Otvori prema zadanim postavkama"</string>
    <string name="app_launch_domain_links_title" msgid="1160925981363706090">"Otvaranje veza"</string>
    <string name="app_launch_open_domain_urls_title" msgid="8914721351596745701">"Otvori podržane veze"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="5367573364240712217">"Otvori bez postavljanja pitanja"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="8250695258211477480">"Podržane veze"</string>
    <string name="app_launch_other_defaults_title" msgid="2516812499807835178">"Ostale zadane postavke"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"<xliff:g id="STORAGE_TYPE">%2$s</xliff:g>, iskorišteno <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="6042049833565674948">"Interna pohrana"</string>
    <string name="storage_type_external" msgid="7738894330670001898">"Vanjska pohrana"</string>
    <string name="app_data_usage" msgid="7942375313697452803">"Upotreba podataka za apl."</string>
    <string name="data_summary_format" msgid="6213211533341068366">"<xliff:g id="SIZE">%1$s</xliff:g> potrošeno od <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="7128074132917008743">"Upotrijebljena pohrana"</string>
    <string name="change" msgid="6657848623929839991">"Promijeni"</string>
    <string name="change_storage" msgid="600475265207060436">"Promijeni pohranu"</string>
    <string name="notifications_label" msgid="2872668710589600731">"Obavijesti"</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">"Isklj. sljedeći br. kat: <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">"Onemogućeno"</string>
    <string name="notifications_redacted" msgid="4493588975742803160">"Osjetljiv sadržaj nije na zaključanom zaslonu"</string>
    <string name="notifications_hidden" msgid="3619610536038757468">"Nije na zaključanom zaslonu"</string>
    <string name="notifications_priority" msgid="1066342037602085552">"Nadjačana je opcija Ne ometaj"</string>
    <string name="notifications_summary_divider" msgid="9013807608804041387">" / "</string>
    <string name="notification_summary_level" msgid="2726571692704140826">"Razina %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">Isključena je <xliff:g id="COUNT_1">%d</xliff:g> kategorija</item>
      <item quantity="few">Isključene su <xliff:g id="COUNT_1">%d</xliff:g> kategorije</item>
      <item quantity="other">Isključeno je <xliff:g id="COUNT_1">%d</xliff:g> kategorija</item>
    </plurals>
    <plurals name="permissions_summary" formatted="false" msgid="6402730318075959117">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> dopuštenje odobreno</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> dopuštenja odobrena</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> dopuštenja odobreno</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> dopuštenja odobreno</item>
      <item quantity="few"><xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g> dopuštenja odobreno</item>
      <item quantity="other"><xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g> dopuštenja odobreno</item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="931276038884210752">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> dodatno dopuštenje</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> dodatna dopuštenja</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> dodatnih dopuštenja</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="1679758182657005375">"Nije odobreno nijedno dopuštenje"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7655100570513818534">"Nije zatraženo nijedno dopuštenje"</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">"Osobno"</string>
    <string name="filter_work_apps" msgid="24519936790795574">"Posao"</string>
    <string name="filter_notif_all_apps" msgid="2299049859443680242">"Aplikacije: sve"</string>
    <!-- no translation found for filter_notif_blocked_apps (3383043508771300704) -->
    <skip />
    <string name="filter_notif_urgent_channels" msgid="3972473613117159653">"Kategorije: hitno"</string>
    <string name="filter_notif_low_channels" msgid="4128487387390004604">"Kategorije: mala važnost"</string>
    <string name="filter_notif_blocked_channels" msgid="5880190882221644289">"Kategorije: isključene"</string>
    <string name="filter_notif_dnd_channels" msgid="1817930848881696728">"Kat.: nadjačav. način Ne uzn."</string>
    <string name="advanced_apps" msgid="4812975097124803873">"Napredno"</string>
    <string name="configure_apps" msgid="6685680790825882528">"Konfiguranje aplikacija"</string>
    <string name="unknown_app" msgid="5275921288718717656">"Nepoznata aplikacija"</string>
    <string name="app_permissions" msgid="4148222031991883874">"Dozvole aplikacijama"</string>
    <string name="app_permissions_summary" msgid="5163974162150406324">"Aplikacije koje koriste značajke <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="tap_to_wake" msgid="7211944147196888807">"Dodirnite za aktivaciju"</string>
    <string name="tap_to_wake_summary" msgid="4341387904987585616">"Dvaput dodirnite bilo gdje na zaslonu da biste aktivirali uređaj"</string>
    <string name="domain_urls_title" msgid="3132983644568821250">"Otvaranje veza"</string>
    <string name="domain_urls_summary_none" msgid="2639588015479657864">"Ne otvara podržane veze"</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">"Otvara <xliff:g id="DOMAIN">%s</xliff:g> i druge URL-ove"</string>
    <string name="domain_urls_apps_summary_off" msgid="1833056772600031220">"Nijedna aplikacija ne otvara podržane veze"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="240214361240709399">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aplikacija otvara podržane veze</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikacije otvaraju podržane veze</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacija otvara podržane veze</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">"Ne otvaraj u ovoj aplikaciji"</string>
    <string name="fingerprint_not_recognized" msgid="1739529686957438119">"Nije prepoznat"</string>
    <string name="default_apps_title" msgid="1660450272764331490">"Zadano"</string>
    <string name="default_for_work" msgid="9152194239366247932">"Zadano za posao"</string>
    <string name="assist_and_voice_input_title" msgid="1733165754793221197">"Pomoćnik i glasovni unos"</string>
    <string name="default_assist_title" msgid="8868488975409247921">"Aplikacija pomoćnik"</string>
    <string name="assistant_security_warning_title" msgid="8673079231955467177">"Želite li da <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> bude vaš pomoćnik?"</string>
    <string name="assistant_security_warning" msgid="8498726261327239136">"Pomoćnik će moći čitati podatke o aplikacijama koje se upotrebljavaju u vašem sustavu, uključujući podatke vidljive na zaslonu ili podatke kojima se može pristupiti u aplikacijama."</string>
    <string name="assistant_security_warning_agree" msgid="7710290206928033908">"Slažem se"</string>
    <string name="assistant_security_warning_disagree" msgid="877419950830205913">"Ne slažem se"</string>
    <string name="choose_voice_input_title" msgid="975471367067718019">"Odabir glasovnog unosa"</string>
    <string name="default_browser_title" msgid="8101772675085814670">"Preglednik"</string>
    <string name="default_browser_title_none" msgid="2124785489953628553">"Nema zadanog preglednika"</string>
    <string name="default_phone_title" msgid="282005908059637350">"Aplikacija za pozive"</string>
    <string name="default_app" msgid="6864503001385843060">"(Zadano)"</string>
    <string name="system_app" msgid="9068313769550747372">"(Sustav)"</string>
    <string name="system_default_app" msgid="3091113402349739037">"(Zadano sustavom)"</string>
    <string name="apps_storage" msgid="4353308027210435513">"Pohrana aplikacija"</string>
    <string name="usage_access" msgid="5479504953931038165">"Pristup upotrebi"</string>
    <string name="permit_usage_access" msgid="4012876269445832300">"Dopusti pristup upotrebi"</string>
    <string name="app_usage_preference" msgid="7065701732733134991">"Postavke upotrebe aplikacije"</string>
    <string name="time_spent_in_app_pref_title" msgid="649419747540933845">"Vrijeme provedeno u aplikaciji"</string>
    <string name="usage_access_description" msgid="1352111094596416795">"Pristup upotrebi omogućuje aplikaciji praćenje drugih aplikacija koje upotrebljavate i učestalosti njihove upotrebe, kao i praćenje mobilnog operatera, postavki jezika i ostalih pojedinosti."</string>
    <string name="memory_settings_title" msgid="7490541005204254222">"Memorija"</string>
    <string name="memory_details_title" msgid="8542565326053693320">"Pojedinosti o memoriji"</string>
    <string name="always_running" msgid="6042448320077429656">"Uvijek se izvodi (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="6611250683037700864">"Ponekad se izvodi (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="348413460168817458">"Rijetko se izvodi (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="6874803757715963097">"Maksimalno"</string>
    <string name="memory_avg_use" msgid="7382015389130622870">"Prosječno"</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">"Prosječno <xliff:g id="MEMORY">%1$s</xliff:g>"</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">"Upozorenja o upotrebi"</string>
    <string name="show_all_apps" msgid="1512506948197818534">"Prikaži potpunu upotrebu uređaja"</string>
    <string name="hide_extra_apps" msgid="5016497281322459633">"Prikaži upotrebu aplikacije"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="467347882627862744">
      <item quantity="one"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacija ne ponaša se na uobičajen način</item>
      <item quantity="few"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacije ne ponašaju se na uobičajen način</item>
      <item quantity="other"><xliff:g id="NUMBER">%2$d</xliff:g> aplikacija ne ponaša se na uobičajen način</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">"Nije optimizirano"</string>
    <string name="high_power_on" msgid="6216293998227583810">"Nije optimizirano"</string>
    <string name="high_power_off" msgid="3393904131961263278">"Optimiziranje upotrebe baterije"</string>
    <string name="high_power_system" msgid="7362862974428225301">"Optimizacija baterije nije dostupna"</string>
    <string name="high_power_desc" msgid="6283926163708585760">"Ne primjenjuje se optimizacija baterije. Baterija će se možda brže isprazniti."</string>
    <string name="high_power_prompt_title" msgid="6358673688590282655">"Želite li dopustiti da aplikacija uvijek radi u pozadini?"</string>
    <string name="high_power_prompt_body" msgid="1031422980602565049">"Ako dopustite da <xliff:g id="APP_NAME">%1$s</xliff:g> uvijek radi u pozadini, to može ubrzati trošenje baterije. \n\nTo možete kasnije promijeniti u izborniku Postavke &gt; Aplikacije i obavijesti."</string>
    <string name="battery_summary" msgid="8044042095190688654">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> potrošnje od posljednjeg potpunog punjenja"</string>
    <string name="battery_power_management" msgid="5571519699679107523">"Upravljanje napajanjem"</string>
    <string name="no_battery_summary" msgid="3528036835462846814">"Nema potrošnje baterije od posljednjeg potpunog punjenja"</string>
    <string name="app_notification_preferences" msgid="1599319335092722613">"Postavke aplikacije"</string>
    <string name="system_ui_settings" msgid="579824306467081123">"Prikaži Prijamnik kor. suč."</string>
    <string name="additional_permissions" msgid="6463784193877056080">"Dodatna dopuštenja"</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">"Želite li podijeliti izvješće o programskoj pogrešci?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4973886976504823801">"IT administrator zatražio je izvješće o programskoj pogrešci radi lakšeg rješavanja problema na uređaju. Moguće je da će se aplikacije i podaci dijeliti."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="3495929560689435496">"IT administrator zatražio je izvješće o programskoj pogrešci radi lakšeg rješavanja problema na uređaju. Moguće je da će se aplikacije i podaci dijeliti, što bi moglo privremeno usporiti uređaj."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="5859287696666024466">"Ovo izvješće o programskoj pogrešci dijeli se s vašim IT administratorom. Više pojedinosti možete saznati od te osobe."</string>
    <string name="share_remote_bugreport_action" msgid="532226159318779397">"Dijeli"</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 punjenje uređaja"</string>
    <string name="usb_use_power_only" msgid="3236391691786786070">"Punjenje povezanog uređaja"</string>
    <string name="usb_use_file_transfers" msgid="1223134119354320726">"Prijenos datoteka"</string>
    <string name="usb_use_file_transfers_desc" msgid="4235764784331804488">"Prijenos datoteka na drugi uređaj"</string>
    <string name="usb_use_photo_transfers" msgid="8192719651229326283">"PTP"</string>
    <string name="usb_use_photo_transfers_desc" msgid="2963034811151325996">"Prijenos fotografija i datoteka ako MTP nije podržan (PTP)"</string>
    <string name="usb_use_tethering" msgid="3944506882789422118">"Modemsko povezivanje USB-om"</string>
    <string name="usb_use_MIDI" msgid="5116404702692483166">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="8473936990076693175">"Upotrebljavajte uređaj kao MIDI"</string>
    <string name="usb_use" msgid="3372728031108932425">"Svrha upotrebe USB-a"</string>
    <string name="usb_default_label" msgid="2211094045594574774">"Zadana konfiguracija USB-a"</string>
    <string name="usb_default_info" msgid="8864535445796200695">"Te će se postavke primjenjivati kada je povezan drugi uređaj, a vaš je telefon otključan. 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 datoteka"</string>
    <string name="usb_summary_tether" msgid="951190049557074535">"Modemsko povezivanje USB-om"</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 datoteke i napajanje"</string>
    <string name="usb_summary_tether_power" msgid="5825335393952752238">"Modemsko povezivanje USB-om 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">"Potpuni pristup u pozadini"</string>
    <string name="assist_access_context_title" msgid="2269032346698890257">"Koristi tekst sa zaslona"</string>
    <string name="assist_access_context_summary" msgid="1991421283142279560">"Dopustite aplikaciji pomoćnika da pristupi sadržaju zaslona kao tekstu"</string>
    <string name="assist_access_screenshot_title" msgid="4034721336291215819">"Koristi snimku zaslona"</string>
    <string name="assist_access_screenshot_summary" msgid="6761636689013259901">"Dopustite aplikaciji pomoćnika da pristupi slici na zaslonu"</string>
    <string name="assist_flash_title" msgid="506661221230034891">"Bljeskanje zaslona"</string>
    <string name="assist_flash_summary" msgid="9160668468824099262">"Rubovi zaslona bljeskaju kada pomoćna aplikacija pristupa tekstu sa zaslona ili snimke zaslona"</string>
    <string name="assist_footer" msgid="1982791172085896864">"Aplikacije pomoćnika mogu vam pomoći na temelju podataka s prikazanog zaslona. Neke aplikacije podržavaju pokretač i usluge glasovnog unosa kako bi vam pružile integriranu pomoć."</string>
    <string name="average_memory_use" msgid="829566450150198512">"Prosječna upotreba memorije"</string>
    <string name="maximum_memory_use" msgid="7493720799710132496">"Maksimalna upotreba memorije"</string>
    <string name="memory_usage" msgid="1781358557214390033">"Upotreba memorije"</string>
    <string name="app_list_memory_use" msgid="6987417883876419338">"Potrošnja aplikacije"</string>
    <string name="memory_details" msgid="5943436005716991782">"Pojedinosti"</string>
    <string name="memory_use_summary" msgid="5608257211903075754">"Prosječna upotreba memorije u posljednja 3 sata: <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="no_memory_use_summary" msgid="2016900536806235588">"U posljednja 3 sata nije bilo upotrebe memorije"</string>
    <string name="sort_avg_use" msgid="3998036180505143129">"Razvrstaj po prosječnoj upotrebi"</string>
    <string name="sort_max_use" msgid="4629247978290075124">"Razvrstaj po maksimalnoj upotrebi"</string>
    <string name="memory_performance" msgid="5661005192284103281">"Izvedba"</string>
    <string name="total_memory" msgid="2017287600738630165">"Ukupna memorija"</string>
    <string name="average_used" msgid="5338339266517245782">"Prosječna upotreba (%)"</string>
    <string name="free_memory" msgid="4003936141603549746">"Dostupno"</string>
    <string name="memory_usage_apps" msgid="5650192998273294098">"Memorija koju upotrebljavaju aplikacije"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="6089210945574265774">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija upotrebljavala je memoriju unatrag <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikacije upotrebljavale su memoriju unatrag <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija upotrebljavalo je memoriju unatrag <xliff:g id="DURATION_1">%2$s</xliff:g></item>
    </plurals>
    <string name="running_frequency" msgid="6622624669948277693">"Učestalost"</string>
    <string name="memory_maximum_usage" msgid="6513785462055278341">"Maksimalna upotreba"</string>
    <string name="no_data_usage" msgid="9131454024293628063">"Nema upotrebe podataka"</string>
    <string name="zen_access_warning_dialog_title" msgid="1198189958031157142">"Želite li dopustiti aplikaciji <xliff:g id="APP">%1$s</xliff:g> pristup opciji Ne ometaj?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="4015885767653010873">"Aplikacija će moći uključiti ili isključiti opciju Ne ometaj i mijenjati povezane postavke."</string>
    <string name="zen_access_disabled_package_warning" msgid="302820100078584431">"Mora ostati uključeno jer je pristup obavijestima uključen"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="558779234015793950">"Želite li opozvati pristup opciji Ne ometaj za aplikaciju <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="5518216907304930148">"Uklonit će se sva pravila Ne ometaj koja je postavila ova aplikacija."</string>
    <string name="ignore_optimizations_on" msgid="6915689518016285116">"Ne optimiziraj"</string>
    <string name="ignore_optimizations_off" msgid="6153196256410296835">"Optimizacija"</string>
    <string name="ignore_optimizations_on_desc" msgid="3549930955839111652">"Baterija se može brže isprazniti. Aplikacijama više neće biti ograničeno korištenje pozadinske baterije."</string>
    <string name="ignore_optimizations_off_desc" msgid="5255731062045426544">"Preporučuje se za dulje trajanje baterije"</string>
    <string name="ignore_optimizations_title" msgid="2829637961185027768">"Želite li dopustiti aplikaciji <xliff:g id="APP">%s</xliff:g> da zanemari optimizacije baterije?"</string>
    <string name="app_list_preference_none" msgid="108006867520327904">"Ništa"</string>
    <string name="work_profile_usage_access_warning" msgid="2918050775124911939">"Isključivanje pristupa upotrebi za tu aplikaciju ne sprječava administratora da prati upotrebu podataka za aplikacije na vašem radnom profilu."</string>
    <string name="accessibility_lock_screen_progress" msgid="2408292742980383166">"Iskorišteno <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 iznad drugih aplikacija"</string>
    <string name="system_alert_window_settings" msgid="8466613169103527868">"Prikaz iznad drugih aplikacija"</string>
    <string name="system_alert_window_apps_title" msgid="7005760279028569491">"Aplikacije"</string>
    <string name="system_alert_window_access_title" msgid="6297115362542361241">"Prikaz iznad drugih aplikacija"</string>
    <string name="permit_draw_overlay" msgid="7456536798718633432">"Dopusti prikaz iznad drugih aplikacija"</string>
    <string name="allow_overlay_description" msgid="8961670023925421358">"Aplikaciji omogućuje da se prikazuje iznad drugih aplikacija koje upotrebljavate. To može ometati upotrebu tih aplikacija ili promijeniti njihov izgled ili ponašanje."</string>
    <string name="keywords_vr_listener" msgid="7441221822576384680">"vr slušatelj virtualne stvarnosti stereo pomoćna usluga"</string>
    <string name="keywords_system_alert_window" msgid="5049498015597864850">"prikaz prozora upozorenja sustava iznad drugih aplikacija"</string>
    <string name="overlay_settings" msgid="6930854109449524280">"Prikaz iznad drugih aplikacija"</string>
    <string name="system_alert_window_summary" msgid="602892301318324492">"Broj aplikacija koje se mogu prikazivati iznad drugih: <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 dopuštenjem"</string>
    <string name="app_permission_summary_allowed" msgid="1505409933012886711">"Dopušteno"</string>
    <string name="app_permission_summary_not_allowed" msgid="2592617058101882802">"Nije dopušteno"</string>
    <string name="keywords_install_other_apps" msgid="761078076051006558">"instalacija aplikacije nepoznati izvori"</string>
    <string name="write_settings" msgid="4797457275727195681">"Izmjena postavki sustava"</string>
    <string name="keywords_write_settings" msgid="6415597272561105138">"pisanje izmjena postavki sustava"</string>
    <string name="write_settings_summary" msgid="4302268998611412696">"Aplikacije s dopuštenjem za izmjenu postavki sustava: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="filter_install_sources_apps" msgid="3102976274848199118">"Može instalirati druge aplikacije"</string>
    <string name="filter_write_settings_apps" msgid="2914615026197322551">"S dopuštenjem za izmjenu postavki sustava"</string>
    <string name="write_settings_title" msgid="4232152481902542284">"S dopuštenjem za izmjenu postavki sustava"</string>
    <string name="write_system_settings" msgid="3482913590601096763">"Izmjena postavki sustava"</string>
    <string name="permit_write_settings" msgid="658555006453212691">"Dopusti izmjenu postavki sustava"</string>
    <string name="write_settings_description" msgid="6868293938839954623">"To dopuštenje omogućuje aplikaciji izmjenu postavki sustava."</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">"Dopusti iz ovog izvora"</string>
    <string name="camera_gesture_title" msgid="1075838577642393011">"Dvostruko obrtanje za fotoaparat"</string>
    <string name="camera_gesture_desc" msgid="1831390075255870960">"Otvaranje aplikacije fotoaparata obrtanjem ručnog zgloba dvaput"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="1651873760405034645">"Pritisnite uključ. dvaput za fotoaparat"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="7355664631775680376">"Brzo otvaranje fotoaparata bez otključavanja zaslona"</string>
    <string name="screen_zoom_title" msgid="5233515303733473927">"Veličina prikaza"</string>
    <string name="screen_zoom_short_summary" msgid="7291960817349834688">"Smanjite ili povećajte stavke na zaslonu"</string>
    <string name="screen_zoom_keywords" msgid="9176477565403352552">"prikaz, gustoća, zumiranje zaslona, skalirati, skaliranje"</string>
    <string name="screen_zoom_summary" msgid="6445488991799015407">"Smanjuje ili povećava stavke na zaslonu. Neke aplikacije na zaslonu mogu promijeniti 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">"Bok, Pero!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6935424214137738647">"Hoćemo danas na kavu?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="5218221201861387402">"Može. 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 povezan"</string>
    <string name="keyboard_disconnected" msgid="1495037256967224035">"Nije povezana"</string>
    <string name="data_usage_summary_format" msgid="7507047900192160585">"Iskorišten podatkovni promet: <xliff:g id="AMOUNT">%1$s</xliff:g>"</string>
    <string name="data_usage_wifi_format" msgid="5417296451392612860">"<xliff:g id="AMOUNT">^1</xliff:g> prometa putem Wi‑Fi-ja"</string>
    <plurals name="notification_summary" formatted="false" msgid="3941492005316143599">
      <item quantity="one">Isključene za <xliff:g id="COUNT">%d</xliff:g> aplikaciju</item>
      <item quantity="few">Isključene za <xliff:g id="COUNT">%d</xliff:g> aplikacije</item>
      <item quantity="other">Isključene za <xliff:g id="COUNT">%d</xliff:g> aplikacija</item>
    </plurals>
    <string name="notification_summary_none" msgid="4586376436702610">"Uključene 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">"Instalirane su 24 aplikacije"</string>
    <string name="storage_summary" msgid="3801281635351732202">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> iskorišteno – <xliff:g id="FREE_SPACE">%2$s</xliff:g> slobodno"</string>
    <string name="storage_summary_with_sdcard" msgid="3290457009629490121">"Interna pohrana: <xliff:g id="PERCENTAGE">%1$s</xliff:g> iskorišteno – <xliff:g id="FREE_SPACE">%2$s</xliff:g> slobodno"</string>
    <string name="display_summary" msgid="6737806235882127328">"Mirovanje nakon <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neaktivnosti"</string>
    <string name="display_dashboard_summary" msgid="4145888780290131488">"Pozadina, mirovanje, veličina fonta"</string>
    <string name="display_summary_example" msgid="9102633726811090523">"Mirovanje nakon 10 minuta neaktivnosti"</string>
    <string name="memory_summary" msgid="8080825904671961872">"Iskorišteno je prosječno <xliff:g id="USED_MEMORY">%1$s</xliff:g> od <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">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> je zadana"</string>
    <string name="location_on_summary" msgid="3637699010986988970">"Uključeno"</string>
    <string name="location_off_summary" msgid="7217264690673949107">"Isključeno"</string>
    <string name="backup_disabled" msgid="485189128759595412">"Sigurnosno kopiranje onemogućeno"</string>
    <string name="android_version_summary" msgid="2935995161657697278">"Ažuriran 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 dopuštena."</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="3208724801293696486">"Glasnoća se ne može promijeniti"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="7919816644946067058">"Pozivanje nije dopušteno"</string>
    <string name="disabled_by_policy_title_sms" msgid="5733307423899610340">"SMS nije dopušten"</string>
    <string name="disabled_by_policy_title_camera" msgid="6225008536855644874">"Fotoaparat nije dopušten"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="4066913623298047094">"Snimka zaslona nije dopuštena"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="7872038990805477554">"Aplikacija se ne može otvoriti"</string>
    <string name="default_admin_support_msg" msgid="4489678214035485367">"Ako imate pitanja, obratite se administratoru"</string>
    <string name="admin_support_more_info" msgid="8901377038510512654">"Više pojedinosti"</string>
    <string name="admin_profile_owner_message" msgid="5860816886981109626">"Vaš administrator može nadzirati aplikacije i postavke povezane s vašim radnim profilom, uključujući postavke, dopuštenja, korporacijski pristup, aktivnost na mreži i podatke o lokaciji uređaja, te njima upravljati."</string>
    <string name="admin_profile_owner_user_message" msgid="3842630535450382172">"Vaš administrator može nadzirati aplikacije i podatke povezane s tim korisnikom, uključujući postavke, dopuštenja, korporacijski pristup, aktivnost na mreži i podatke o lokaciji uređaja, te njima upravljati."</string>
    <string name="admin_device_owner_message" msgid="6232893638259790789">"Vaš administrator može nadzirati aplikacije i podatke povezane s ovim uređajem, uključujući postavke, dopuštenja, korporacijski pristup, aktivnost na mreži i podatke o lokaciji uređaja, te njima upravljati."</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="7778958849468560027">"Žarišna je točka uključena"</string>
    <string name="condition_hotspot_summary" msgid="3433182779269409683">"Prijenosna Wi-Fi žarišna točka <xliff:g id="ID_1">%1$s</xliff:g> aktivna je, a Wi-Fi za ovaj uređaj nije uključen."</string>
    <string name="condition_airplane_title" msgid="287356299107070503">"Način rada u zrakoplovu uklj."</string>
    <string name="condition_airplane_summary" msgid="7098837989877102577">"Kada je uključen način rada u zrakoplovu, isključeni su Wi‑Fi, Bluetooth i mobilna mreža. Wi‑Fi i Bluetooth moguće je ponovo uključiti."</string>
    <string name="condition_zen_title" msgid="2897779738211625">"Način Ne uznemiravaj uključen"</string>
    <string name="condition_battery_title" msgid="3272131008388575349">"Štednja baterije je uključena"</string>
    <string name="condition_battery_summary" msgid="507347940746895275">"Štednja baterije isključuje neke značajke uređaja i ograničava aplikacije"</string>
    <string name="condition_cellular_title" msgid="1327317003797575735">"Mobilni su podaci isključeni"</string>
    <string name="condition_cellular_summary" msgid="1818046558419658463">"Internet je dostupan samo putem Wi-Fi-ja"</string>
    <string name="condition_bg_data_title" msgid="2483860304802846542">"Štednja podat. prometa uključ."</string>
    <string name="condition_bg_data_summary" msgid="656957852895282228">"Pozadinski podaci dostupni su samo putem Wi-Fi-ja. To može utjecati na neke aplikacije ili usluge kada Wi-Fi nije dostupan."</string>
    <string name="condition_work_title" msgid="7293722361184366648">"Radni je profil isključen"</string>
    <string name="condition_work_summary" msgid="7543202177571590378">"Isključene su aplikacije, sinkronizacija u pozadini i ostale značajke povezane s vašim radnim profilom."</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4930240942726349213">"Uključi zvuk"</string>
    <string name="condition_device_muted_title" product="tablet" msgid="3095044864508335783">"Na uređaju je isključen zvuk"</string>
    <string name="condition_device_muted_title" product="default" msgid="5818278137378379647">"Na telefonu je isključen zvuk"</string>
    <string name="condition_device_muted_summary" msgid="5445341185705628047">"Zvučni signal poziva i obavijesti bit će isključen"</string>
    <string name="condition_device_vibrate_title" product="tablet" msgid="1983420639621523345">"Uređaj je postavljen na vibriranje"</string>
    <string name="condition_device_vibrate_title" product="default" msgid="1087633233379991925">"Telefon je postavljen na vibriranje"</string>
    <string name="condition_device_vibrate_summary" product="tablet" msgid="433514444618164607">"Uređaj će vibrirati za pozive i obavijesti"</string>
    <string name="condition_device_vibrate_summary" product="default" msgid="5877034997839162763">"Telefon će vibrirati za pozive i obavijesti"</string>
    <string name="night_display_suggestion_title" msgid="6602129097059325291">"Postavite raspored Noćnog svjetla"</string>
    <string name="night_display_suggestion_summary" msgid="228346372178218442">"Automatski oboji zaslon svake noći"</string>
    <string name="condition_night_display_title" msgid="5599814941976856183">"Noćno je svjetlo uključeno"</string>
    <string name="condition_night_display_summary" msgid="5443722724310650381">"Zaslon je obojen žuto. To bi vam moglo pomoći da zaspite."</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">"Više od <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="8223690393059519879">"i 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">+<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>
    <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">"Upotrebljavaj hladnije boje prikaza"</string>
    <string name="color_temperature_toast" msgid="4974218172133854827">"Da biste primijenili promjenu boje, isključite zaslon"</string>
    <string name="camera_laser_sensor_switch" msgid="8913588990743234440">"Laserski senzor fotoaparata"</string>
    <string name="ota_disable_automatic_update" msgid="2319639631655915050">"Automatska ažuriranja sustava"</string>
    <string name="ota_disable_automatic_update_summary" msgid="940729694354373087">"Primijeni ažuriranja pri ponovnom pokretanju uređaja"</string>
    <string name="usage" msgid="2977875522080448986">"Potrošnja"</string>
    <string name="cellular_data_usage" msgid="2155683719898158203">"Potrošnja mobilnih podataka"</string>
    <string name="app_cellular_data_usage" msgid="5468472735806533448">"Potrošnja podatkovnog prometa za aplikacije"</string>
    <string name="wifi_data_usage" msgid="771603760674507659">"Potrošnja podatkovnog prometa putem Wi-Fi-ja"</string>
    <string name="ethernet_data_usage" msgid="5108764537574354616">"Potrošnja ethernet podataka"</string>
    <string name="wifi" msgid="1081550856200013637">"Wi-Fi"</string>
    <string name="ethernet" msgid="6600095783781389720">"Ethernet"</string>
    <string name="cell_data_template" msgid="405684854174361041">"<xliff:g id="AMOUNT">^1</xliff:g> mobilnih podataka"</string>
    <string name="wifi_data_template" msgid="6265570748799357386">"<xliff:g id="AMOUNT">^1</xliff:g> Wi-Fi 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 limit"</string>
    <string name="app_usage_cycle" msgid="8877223251648092131">"Ciklus potrošnje pod. prometa"</string>
    <string name="cell_data_warning" msgid="1985956818884847057">"Upozorenje o potrošnji podatkovnog prometa za <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="1578367585799358854">"Ograničenje podatkovnog prometa od <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="6888825370687743208">"Upozorenje o potrošnji podatkovnog prometa za <xliff:g id="ID_1">^1</xliff:g>/ograničenje podatkovnog prometa od <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="billing_cycle_fragment_summary" msgid="8231066353654583106">"Svaki mjesec na <xliff:g id="ID_1">%1$s</xliff:g>. dan"</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">"Mobilni operater može obračunavati podatke na drugačiji način od uređaja"</string>
    <string name="data_used_template" msgid="3245919669966296505">"Potrošili ste <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 potrošnji"</string>
    <string name="data_warning_footnote" msgid="776341964125603711">"Upozorenje o potrošnji podatkovnog prometa i ograničenje podatkovnog prometa mjeri vaš uređaj. Ta se mjerenja mogu razlikovati od mjerenja vašeg mobilnog operatera."</string>
    <string name="set_data_limit" msgid="2901526323210516923">"Postavi ograničenje potrošnje"</string>
    <string name="data_limit" msgid="1885406964934590552">"Ograničenje podataka"</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">"Konfiguriraj"</string>
    <string name="data_usage_other_apps" msgid="3272872663517382050">"Ostale aplikacije uključene u upotrebu"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="2635267833484232703">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija smije neograničeno upotrebljavati podatkovni promet kad je uključena štednja podatkovnog prometa</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikacije smiju neograničeno upotrebljavati podatkovni promet kad je uključena Štednja podatkovnog prometa</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija smije neograničeno upotrebljavati podatkovni promet kad je uključena Štednja podatkovnog prometa</item>
    </plurals>
    <string name="data_usage_title" msgid="3659356290392241789">"Primarni podaci"</string>
    <string name="data_usage_wifi_title" msgid="7063659423081820720">"Podaci putem Wi‑Fi-ja"</string>
    <string name="data_used" msgid="5116389957228457203">"Potrošeno: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_used_formatted" msgid="2989129931961311051">"Iskorišteno: <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="1134445012475270295">"Više od <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 operater prije <xliff:g id="ID_1">^1</xliff:g> <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 operater <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="1766859656868932996">"Upravo je ažurirano"</string>
    <string name="launch_mdp_app_text" msgid="6751296320061773169">"Prikaži plan"</string>
    <string name="launch_wifi_text" msgid="2311424914664372687">"Prikaz pojedinosti"</string>
    <string name="data_saver_title" msgid="8034286939200289826">"Štednja podat. prometa"</string>
    <string name="unrestricted_data_saver" msgid="952796077540228711">"Neograničeni podaci"</string>
    <string name="restrict_background_blacklisted" msgid="3995443391711013068">"Pozadinski su podaci 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">"Ograniči podatkovni promet"</string>
    <string name="unrestricted_app_title" msgid="4465437191723332066">"Neograničena potroš. podataka"</string>
    <string name="unrestricted_app_summary" msgid="6458008993501723912">"Dopusti neograničen pristup podacima kada je Štednja podatkovnog prometa uključena"</string>
    <string name="home_app" msgid="4066188520886810030">"Početna aplikacija"</string>
    <string name="no_default_home" msgid="7184117487704520238">"Nema zadane početne"</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 uređaja. Kada je isključeno, uređaj ne može primati pozive, poruke i obavijesti niti oglašavati alarm."</string>
    <string name="lockpattern_settings_require_pin_before_startup_summary" msgid="6022831284097476933">"Zahtijeva PIN za pokretanje uređaja. Kada je isključeno, uređaj ne može primati pozive, poruke i obavijesti niti oglašavati alarm."</string>
    <string name="lockpattern_settings_require_password_before_startup_summary" msgid="6818285221244966231">"Zahtijeva zaporku za pokretanje uređaja. Kada je isključeno, uređaj ne može primati pozive, poruke i obavijesti niti oglašavati alarm."</string>
    <string name="suggestion_additional_fingerprints" msgid="2214281455363797037">"Dodajte još jedan otisak prsta"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="5471253233176471245">"Otključajte 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">"Odmah uključi"</string>
    <string name="battery_saver_button_turn_off" msgid="5916996792004611890">"Odmah isključi"</string>
    <string name="not_battery_optimizing" msgid="5362861851864837617">"Ne upotrebljava optimizaciju baterije"</string>
    <string name="lockscreen_remote_input" msgid="969871538778211843">"Spriječi unos odgovora ili drugog teksta u obavijesti kada je uređaj zaključan"</string>
    <string name="default_spell_checker" msgid="8506899870026026660">"Zadana provjera pravopisa"</string>
    <string name="choose_spell_checker" msgid="6596539862291699367">"Odabir provjere pravopisa"</string>
    <string name="spell_checker_master_switch_title" msgid="8763132750954344372">"Upotreba provjere 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">"publicVersion"</string>
    <string name="notification_log_details_priority" msgid="8371354971235991398">"prioritet"</string>
    <string name="notification_log_details_importance" msgid="2153168790791683139">"značaj"</string>
    <string name="notification_log_details_explanation" msgid="1914295130775393551">"objašnjenje"</string>
    <string name="notification_log_details_badge" msgid="3258183328267662285">"može prikazivati značku"</string>
    <string name="notification_log_details_content_intent" msgid="1113554570409128083">"namjera"</string>
    <string name="notification_log_details_delete_intent" msgid="905118520685297007">"namjera brisanja"</string>
    <string name="notification_log_details_full_screen_intent" msgid="7118560817013522978">"namjera cijelog zaslona"</string>
    <string name="notification_log_details_actions" msgid="242523930165118066">"radnje"</string>
    <string name="notification_log_details_title" msgid="7177091647508863295">"naslov"</string>
    <string name="notification_log_details_remoteinput" msgid="8328591329858827409">"daljinski ulazi"</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_sound" msgid="5506232879598808099">"zvuk"</string>
    <string name="notification_log_details_vibrate" msgid="6890065466625335940">"vibriranje"</string>
    <string name="notification_log_details_default" msgid="2345249399796730861">"zadano"</string>
    <string name="notification_log_details_none" msgid="184131801230614059">"ništa"</string>
    <string name="notification_log_details_ranking_null" msgid="244660392058720919">"Objekt rangiranja nedostaje."</string>
    <string name="notification_log_details_ranking_none" msgid="599607025882587844">"Objekt rangiranja ne sadrži tu tipku."</string>
    <string name="display_cutout_emulation" msgid="7466869822418376317">"Urez na zaslonu"</string>
    <string name="display_cutout_emulation_keywords" msgid="4495418317471622562">"obrezana slika za zaslon, urez"</string>
    <string name="display_cutout_emulation_device_default" msgid="7957250558326167503">"Zadana postavka uređaja"</string>
    <string name="special_access" msgid="3458780842491881155">"Poseban pristup za aplikacije"</string>
    <plurals name="special_access_summary" formatted="false" msgid="260765309935675867">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aplikacija može upotrebljavati neograničene podatke</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikacije mogu upotrebljavati neograničene podatke</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacija može upotrebljavati neograničene podatke</item>
    </plurals>
    <string name="confirm_convert_to_fbe_warning" msgid="1487005506049137659">"Želite li doista izbrisati korisničke podatke i prijeći na enkripciju datoteka?"</string>
    <string name="button_confirm_convert_fbe" msgid="7101855374850373091">"Izbriši i pretvori"</string>
    <string name="reset_shortcut_manager_throttling" msgid="6495066467198668994">"Poništi ograničavanje brzine ShortcutManagera"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="1826770872063707900">"Ograničavanje brzine ShortcutManagera poništeno je"</string>
    <string name="notification_suggestion_title" msgid="387052719462473500">"Upravljanje informacijama na zaključanom zaslonu"</string>
    <string name="notification_suggestion_summary" msgid="8521159741445416875">"Prikazivanje ili sakrivanje sadržaja obavijesti"</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 premium SMS-ovima"</string>
    <string name="premium_sms_warning" msgid="9086859595338944882">"Premium SMS-ovi mogu se dodatno naplaćivati i povećat će vaš račun. Ako nekoj aplikaciji date to dopuštenje, moći ćete slati premium SMS-ove pomoću te aplikacije."</string>
    <string name="premium_sms_access" msgid="4660047004791638305">"Pristup premium SMS-ovima"</string>
    <string name="bluetooth_disabled" msgid="6244000672828617410">"Isključeno"</string>
    <string name="bluetooth_connected_summary" msgid="7672528674593152862">"Povezano s uređajem <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="9173661896296663932">"Povezano s više uređaja"</string>
    <string name="demo_mode" msgid="2798762752209330277">"Demo način korisničkog sučelja sustava"</string>
    <string name="dark_ui_mode" msgid="4176511670311366886">"Tamni način"</string>
    <string name="dark_ui_mode_title" msgid="3471395820322819817">"Postavite Tamni način"</string>
    <string name="quick_settings_developer_tiles" msgid="5947788063262762448">"Pločice brzih postavki za razvojne programere"</string>
    <string name="winscope_trace_quick_settings_title" msgid="1294290008255732032">"Winscope praćenje"</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">"Omogućuje pretraživanjima kontakata vaše organizacije da identificiraju pozivatelje i kontakte"</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 pohranom"</string>
    <string name="automatic_storage_manager_text" msgid="4562950476680600604">"Upravitelj pohrane uklanja fotografije i videozapise s uređaja za koje je napravljena sigurnosna kopija kako bi oslobodio prostor za pohranu."</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 pohrane"</string>
    <string name="automatic_storage_manager_master_switch_title" msgid="6792996736190821417">"Upotreba upravitelja pohrane"</string>
    <string name="deletion_helper_automatic_title" msgid="6605660435498272520">"Automatski"</string>
    <string name="deletion_helper_manual_title" msgid="7947432164411214029">"Priručnik"</string>
    <string name="deletion_helper_preference_title" msgid="5271510052022285884">"Oslobodi prostor odmah"</string>
    <string name="gesture_preference_title" msgid="5280023307132819052">"Pokreti"</string>
    <string name="gesture_preference_summary" product="default" msgid="8627850388011956901">"Brzi pokreti za upravljanje telefonom"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4717535378272065510">"Brzi pokreti za upravljanje tabletom"</string>
    <string name="gesture_preference_summary" product="device" msgid="4205941452664950852">"Brzi pokreti za upravljanje uređajem"</string>
    <string name="double_tap_power_for_camera_title" msgid="64716226816032800">"Otvaranje fotoaparata"</string>
    <string name="double_tap_power_for_camera_summary" msgid="242037150983277829">"Da biste brzo otvorili fotoaparat, dvaput pritisnite tipku za uključivanje/isključivanje. Funkcionira na svim zaslonima."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="6500405261202883589">"Brzo otvaranje fotoaparata"</string>
    <string name="double_twist_for_camera_mode_title" msgid="4877834147983530479">"Prebacivanje fotoaparata"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="122977081337563340"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="4689410222517954869">"Brže snimanje selfieja"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="2513907834903543667">"Prijeđite prstom prema gore po gumbu početnog zaslona"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="5367798220225997418">"Da biste promijenili aplikaciju, prijeđite prstom prema gore po gumbu početnog zaslona. Ponovo prijeđite prstom prema gore da biste vidjeli sve aplikacije. Funkcionira na svim zaslonima. Više nećete imati gumb Pregled u donjem desnom kutu zaslona."</string>
    <string name="swipe_up_to_switch_apps_suggestion_title" msgid="1465200107913259595">"Isprobajte novi gumb početnog zaslona"</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="4825314186907812743">"Uključite novi pokret da biste promijenili aplikaciju"</string>
    <string name="ambient_display_title" product="default" msgid="5144814600610448504">"Dvaput dodirnite da biste provjerili telefon"</string>
    <string name="ambient_display_title" product="tablet" msgid="8688795028609563837">"Dvaput dodirnite da biste provjerili tablet"</string>
    <string name="ambient_display_title" product="device" msgid="3423781975742145894">"Dvaput dodirnite da biste provjerili uređaj"</string>
    <string name="ambient_display_summary" msgid="8534654210539169707">"Da biste pogledali vrijeme, obavijesti i druge informacije, dvaput dodirnite zaslon."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="818688002837687268">"Podizanje telefona za provjeru"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="4455864282995698097">"Podignite da biste provjerili tablet"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="5380534405773531175">"Podignite da biste provjerili uređaj"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="3436302177038243869">"Da biste pogledali vrijeme, obavijesti i druge informacije, podignite telefon."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="4938504160398665156">"Da biste pogledali vrijeme, obavijesti i druge informacije, podignite tablet."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="4264958533375250254">"Da biste pogledali vrijeme, obavijesti i druge informacije, podignite uređaj."</string>
    <string name="ambient_display_reach_title" msgid="6519700935117799437">"Pokret dohvaćanja"</string>
    <string name="ambient_display_reach_summary" product="default" msgid="1220765153509895824"></string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="5816346492253270243">"Otisak prsta za obavijesti"</string>
    <string name="fingerprint_gesture_screen_title" msgid="8562169633234041196">"Pokret za otisak prsta"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="1770661868393713922">"Da biste pogledali obavijesti, prijeđite prstom prema dolje po senzoru otiska prsta na stražnjoj strani telefona."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet" msgid="902719947767712895">"Da biste pogledali obavijesti, prijeđite prstom prema dolje po senzoru otiska prsta na stražnjoj strani tableta."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="device" msgid="5372926094116306647">"Da biste pogledali obavijesti, prijeđite prstom prema dolje po senzoru otiska prsta na stražnjoj strani uređaja."</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="1677291167470357802">"Brz pregled obavijesti"</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">"Početni program za pokretanje već je otključan"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="3361344735430813695">"Najprije se povežite s internetom"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="2479038689567925511">"Povežite se s internetom ili se obratite mobilnom operateru"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="4149387448213399630">"Nije dostupno na uređajima koje je zaključao mob. operater"</string>
    <string name="oem_lock_info_message" msgid="9218313722236417510">"Ponovo pokrenite uređaj da biste omogućili značajku zaštite uređaja."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="7517560170441007788">"Ukupno dostupno: <xliff:g id="SIZE">%1$s</xliff:g>\n\nPosljednji put 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">"Veze će se otvarati u aplikacijama čak i ako te aplikacije nisu instalirane"</string>
    <string name="web_action_section_title" msgid="7364647086538399136">"Instant aplikacije"</string>
    <string name="instant_apps_settings" msgid="8827777916518348213">"Postavke za Instant aplikacije"</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 za korisnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="configure_section_header" msgid="7391183586410814450">"Konfiguriranje"</string>
    <string name="auto_sync_account_title" msgid="898796354710116383">"Automatski sinkroniziraj podatke"</string>
    <string name="auto_sync_personal_account_title" msgid="8496263182646100610">"Automatski sinkroniziraj osobne podatke"</string>
    <string name="auto_sync_work_account_title" msgid="4489172450037434152">"Automatski sinkroniziraj radne podatke"</string>
    <string name="auto_sync_account_summary" msgid="692499211629185107">"Dopusti aplikacijama da automatski osvježavaju podatke"</string>
    <string name="account_sync_title" msgid="7214747784136106491">"Sinkronizacija računa"</string>
    <string name="account_sync_summary_some_on" msgid="3375930757891381175">"Sinkronizacija uključena za <xliff:g id="ID_1">%1$d</xliff:g> od sljedećeg broja stavki: <xliff:g id="ID_2">%2$d</xliff:g>"</string>
    <string name="account_sync_summary_all_on" msgid="570431636622254156">"Sinkronizacija uključena za sve stavke"</string>
    <string name="account_sync_summary_all_off" msgid="8782409931761182734">"Sinkronizacija isključena za sve stavke"</string>
    <string name="enterprise_privacy_settings" msgid="1177106810374146496">"Informacije 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 <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="7402406406883832509">"Da bi osigurala pristup vašim radnim podacima, vaša organizacija može promijeniti postavke i instalirati softver na vaš uređaj.\n\nViše pojedinosti zatražite od administratora svoje organizacije."</string>
    <string name="enterprise_privacy_exposure_category" msgid="7313392680107938517">"Vrste podataka koje može vidjeti vaša organizacija"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="9079283547182933771">"Izmjene koje je unio administrator 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 povezani s vašim radnim računom, na primjer e-pošta i kalendar"</string>
    <string name="enterprise_privacy_installed_packages" msgid="2313698828178764590">"Popis aplikacija na vašem uređaju"</string>
    <string name="enterprise_privacy_usage_stats" msgid="4398411405572759370">"Utrošeno vrijeme i količina podataka u svakoj aplikaciji"</string>
    <string name="enterprise_privacy_network_logs" msgid="161722817268849590">"Najnoviji zapisnik mrežnog prometa"</string>
    <string name="enterprise_privacy_bug_reports" msgid="843225086779037863">"Najnovije izvješće o programskoj pogrešci"</string>
    <string name="enterprise_privacy_security_logs" msgid="5377362481617301074">"Najnoviji sigurnosni zapisnik"</string>
    <string name="enterprise_privacy_none" msgid="7706621148858381189">"Ništa"</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 procijenjen je i možda ne uključuje aplikacije koje su instalirane izvan Trgovine Play."</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">"Dopuštenja za lokaciju"</string>
    <string name="enterprise_privacy_microphone_access" msgid="5717375623568864441">"Dopuštenja za mikrofon"</string>
    <string name="enterprise_privacy_camera_access" msgid="4858146118537519375">"Dopuštenja za fotoaparat"</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 tipkovnica"</string>
    <string name="enterprise_privacy_input_method_name" msgid="4941106433683067953">"Postavljeno na <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="4409098287763221215">"Aktiviran je uvijek uključeni VPN"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="9217774730260037434">"Uvijek uključeni VPN aktiviran je u osobnom profilu"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="7244472958208315814">"Uvijek uključeni VPN aktiviran je u radnom profilu"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="7936664553416257333">"Postavljen je globalni HTTP proxy"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="2019652712782510262">"Pouzdane vjerodajnice"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="2279084820904076599">"Pouzdane vjerodajnice na vašem osobnom profilu"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="6187377647815301809">"Pouzdane vjerodajnice 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 poništiti zaporku"</string>
    <string name="enterprise_privacy_wipe_device" msgid="2821960015797241790">"Administrator može izbrisati sve podatke na uređaju"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="1001255609345002878">"Broj neuspjelih pokušaja unosa zaporke prije brisanja svih podataka s uređaja"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="4040565826652951057">"Broj neuspjelih pokušaja unosa zaporke prije brisanja podataka s 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 snimanje</item>
      <item quantity="few">Aplikacije za snimanje</item>
      <item quantity="other">Aplikacija za snimanje</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="3545972964391065220">"Aplikacija Kalendar"</string>
    <string name="default_contacts_app_title" msgid="3497370557378660098">"Aplikacija Kontakti"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="42826975161049245">
      <item quantity="one">Aplikacija klijenta e-pošte</item>
      <item quantity="few">Aplikacije klijenta e-pošte</item>
      <item quantity="other">Aplikacija klijenta e-pošte</item>
    </plurals>
    <string name="default_map_app_title" msgid="7560143381633608567">"Aplikacija Karta"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="6714041230953195024">
      <item quantity="one">Aplikacija telefona</item>
      <item quantity="few">Aplikacije telefona</item>
      <item quantity="other">Aplikacija telefona</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">"Glazba i zvuk"</string>
    <string name="storage_games" msgid="7703159201697117621">"Igre"</string>
    <string name="storage_other_apps" msgid="5524321740031718083">"Ostale aplikacije"</string>
    <string name="storage_files" msgid="8581083146777364063">"Datoteke"</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">"Upotrijebljeno od <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_percent_full" msgid="6095012055875077036">"upot."</string>
    <string name="clear_instant_app_data" msgid="2004222610585890909">"Izbriši podatke aplikacije"</string>
    <string name="clear_instant_app_confirmation" msgid="7451671214898856857">"Želite li ukloniti tu 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">"Audiodatoteke"</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;Provjerite je li ova aplikacija pouzdana&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; upotrebljava sadržaj na zaslonu za procjenu onoga što se može automatski popuniti."</string>
    <string name="debug_autofill_category" msgid="8050326960545979035">"Automatski popuni"</string>
    <string name="autofill_logging_level_title" msgid="899483289251346778">"Razina zapisivanja"</string>
    <string name="autofill_max_partitions" msgid="7590272120101271461">"Maksimalan broj zahtjeva po sesiji"</string>
    <string name="autofill_max_visible_datasets" msgid="4531033613378881109">"Maksimalan broj vidljivih skupova podataka"</string>
    <string name="autofill_reset_developer_options" msgid="5819016237049525099">"Vrati na zadane vrijednosti"</string>
    <string name="autofill_reset_developer_options_complete" msgid="7548288932341619412">"Opcije automatskog popunjavanja za razvojne programere vraćene su na zadano"</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 traci statusa"</string>
    <string name="storage_manager_indicator" msgid="1516810749625915020">"Upravitelj pohrane: <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">"Isključiti upravitelja pohrane?"</string>
    <string name="storage_movies_tv" msgid="5498394447562086890">"Aplikacije za filmove i TV"</string>
    <string name="carrier_provisioning" msgid="4398683675591893169">"Informacije o uslugama mobilnog operatera"</string>
    <string name="trigger_carrier_provisioning" msgid="3434865918009286187">"Pokretanje usluga mobilnog operatera"</string>
    <string name="zen_suggestion_title" msgid="798067603460192693">"Ažuriranje načina Ne uznemiravaj"</string>
    <string name="zen_suggestion_summary" msgid="5928686804697233014">"Pauzirajte obavijesti da biste ostali usredotočeni"</string>
    <string name="disabled_low_ram_device" msgid="3751578499721173344">"Ova značajka nije dostupna na ovom uređaju"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1294470289520660584">"Primijeni potpuna mjerenja GNSS-a"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="496344699046454200">"Prati sve konstelacije i frekvencije GNSS-a bez određivanja radnog omjera"</string>
    <string name="show_first_crash_dialog" msgid="8889957119867262599">"Uvijek prikaži dijaloški okvir o rušenju"</string>
    <string name="show_first_crash_dialog_summary" msgid="703224456285060428">"Prikaži dijaloški okvir svaki put kada se aplikacija sruši"</string>
    <string name="directory_access" msgid="4722237210725864244">"Pristup direktoriju"</string>
    <string name="keywords_directory_access" msgid="360557532842445280">"pristup direktoriju"</string>
    <string name="directory_on_volume" msgid="1246959267814974387">"<xliff:g id="VOLUME">%1$s</xliff:g> (<xliff:g id="DIRECTORY">%2$s</xliff:g>)"</string>
    <string name="unsupported_setting_summary" product="default" msgid="11246953620654225">"Postavka nije podržana na telefonu"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="6328431665635673717">"Postavka nije podržana na tabletu"</string>
    <string name="unsupported_setting_summary" product="device" msgid="2348970994972110886">"Postavka nije podržana na uređaju"</string>
    <string name="disabled_for_user_setting_summary" msgid="3388525317680711262">"Postavku ne može promijeniti trenutačni korisnik"</string>
    <string name="disabled_dependent_setting_summary" msgid="8291322239940946902">"Ovisi o drugoj postavci"</string>
    <string name="unknown_unavailability_setting_summary" msgid="4589584678033059435">"Postavka nije dostupna"</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="bluetooth_on_while_driving_pref" msgid="2460847604498343330">"Upotreba Bluetootha tijekom vožnje"</string>
    <string name="bluetooth_on_while_driving_summary" msgid="3196190732516898541">"Automatsko uključivanje Bluetootha tijekom vožnje"</string>
    <string name="change_wifi_state_title" msgid="3261945855372885427">"Upravljanje Wi-Fi-jem"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="7942268646980694224">"Dopusti aplikaciji upravljanje Wi-Fi-jem"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8434262633905502679">"Aplikaciji omogućuje da uključuje ili isključuje Wi-Fi, traži Wi-Fi mreže i povezuje se s njima, dodaje ili uklanja mreže te pokreće lokalnu žarišnu točku"</string>
    <string name="media_output_title" msgid="115223550977351699">"Reproduciraj medije na"</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">"Nije dostupno tijekom poziva"</string>
    <string name="media_output_summary_unavailable" msgid="7970304720507697019">"Nije dostupno"</string>
    <string name="take_call_on_title" msgid="6066362463436122655">"Preuzmi poziv na uređaju"</string>
    <string name="battery_suggestion_title" product="tablet" msgid="752439050748267917">"Poboljšajte trajanje baterije tableta"</string>
    <string name="battery_suggestion_title" product="device" msgid="1507272328369733005">"Poboljšajte trajanje baterije uređaja"</string>
    <string name="battery_suggestion_title" product="default" msgid="4038053023336285165">"Poboljšajte trajanje baterije telefona"</string>
    <string name="battery_suggestion_summary" msgid="4585677159811722359"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="7840226017975251549">"Sprječavanje zvonjenja"</string>
    <string name="gesture_prevent_ringing_title" msgid="2483159069038138740">"Istovremeno pritisnite tipku za uključivanje/isključivanje i pojačavanje glasnoće"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="5724512060316688779">"Prečac za sprečavanje zvonjenja"</string>
    <string name="prevent_ringing_option_vibrate" msgid="7286821846542822661">"Vibriranje"</string>
    <string name="prevent_ringing_option_mute" msgid="7551545579059879853">"Isključi zvuk"</string>
    <string name="prevent_ringing_option_none" msgid="4656046650769569175">"Ne poduzimaj 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či (isključi zvuk)"</string>
    <string name="prevent_ringing_option_none_summary" msgid="5013718946609276137">"Isključi"</string>
    <string name="pref_title_network_details" msgid="7186418845727358964">"Pojedinosti o mreži"</string>
    <string name="about_phone_device_name_warning" msgid="8885670415541365348">"Naziv vašeg uređaja vidljiv je aplikacijama na vašem telefonu. Mogu ga vidjeti i drugi ljudi kada se povežete s Bluetooth uređajima ili postavite Wi-Fi žarišnu točku."</string>
    <string name="devices_title" msgid="7701726109334110391">"Uređaji"</string>
    <string name="high_frequency_display_device_title" msgid="2327369124536178715">"Ploča visoke frekvencije"</string>
    <string name="high_frequency_display_device_summary" msgid="1476189143535389304">"Omogući virtualnu ploču visoke frekvencije"</string>
    <string name="homepage_all_settings" msgid="1245540304900512919">"Sve postavke"</string>
    <string name="homepage_personal_settings" msgid="3998213046366125494">"Vaše postavke"</string>
    <string name="cbrs_data_switch" msgid="2438108549734702331">"Podaci CBRS-a"</string>
    <string name="cbrs_data_switch_summary" msgid="1359701543634843588">"Podaci CBRS-a"</string>
    <string name="choose_network_title" msgid="5702586742615861037">"Odaberite mrežu"</string>
    <string name="network_disconnected" msgid="2933191767567503504">"Nije povezano"</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">"Nije pronađena nijedna mreža. Pokušajte ponovo."</string>
    <string name="forbidden_network" msgid="4626592887509826545">"(zabranjeno)"</string>
    <!-- no translation found for no_sim_card (1360669528113557381) -->
    <skip />
</resources>
